/*
 * @(#)GeneradorArbol.java	 
 *
 * Copyright 2008 Universidad Francisco de Paula Santander (UFPS).
 * Todos los Derechos Reservados. 
 * Creado el 07/10/08, 11:23:38 AM
 */
package com.ufps.cuatro.util.generadores;

import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.tree.DefaultMutableTreeNode;

import com.ufps.cuatro.controlador.render.UtilRender;
import com.ufps.cuatro.modelo.analizador.ObjetoReflexion;
import com.ufps.cuatro.modelo.biblioteca.BibliotecaTrabajo;
import com.ufps.cuatro.modelo.biblioteca.ItemStaticListModelObject;
import com.ufps.cuatro.modelo.biblioteca.StaticListModelObject;
import com.ufps.cuatro.modelo.codificacion.PaqueteClass;
import com.ufps.cuatro.modelo.old.ComponenteBeans;
import com.ufps.cuatro.modelo.representacion.ModeloAsociado;
import com.ufps.cuatro.modelo.representacion.ObjetoTipoDatoReflexion;
import com.ufps.cuatro.modelo.representacion.PropiedadBeans;
import com.ufps.cuatro.modelo.representacion.TipoMetodo;
import com.ufps.cuatro.modelo.representacion.UtilRepresentacion;
import com.ufps.cuatro.modelo.representacion.componente.Componente;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidor;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorContenedor;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorContenedorEspejo;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorContenedorLibre;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorExtra;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGenerador;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorClaseCompleja;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorEnum;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorMetodo;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorMetodoGetter;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorMetodoSetter;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorString;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorUnitario;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGeneradorVinculador;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorIntegrador;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorIntegradorExtra;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorIntegradorMetodo;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorIntegradorSimple;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorModeloAsociado;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteGeneradoInterno;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteGeneradoSimple;
import com.ufps.cuatro.util.InformacionNodo;
import com.ufps.cuatro.util.base.ComponenteBasePersonalizado;
import com.ufps.cuatro.util.base.ComponenteBaseStandar;
import com.ufps.cuatro.util.opciones.MyPreferences;
import com.ufps.cuatro.util.opciones.UtilOpciones;

/**
 * <i><b>GeneradorArbol:</b></i>Esta Clase abstracta se encarga de generar
 * estructuras jerarquicas tipo arbol de los objetos contenedores recibidos. 
 *  
 * @author  Carlos Alberto Torres Camargo
 * @version 1.0 07/10/08 
 * @see     Serializable 
 */
public abstract class GeneradorArbol implements Serializable {
    private static final long serialVersionUID = -8045657985741439971L;
    
    /**
     * Utilizado para formatear la Salida en una etiqueta. Normal indica
     * que no se realizará ningun formato, el texto será plano.
     */
    public final static int FORMAT_LABEL_NORMAL = 0;
    /**
     * Utilizado para formatear la Salida en una etiqueta. Label A indica
     * que se aplicará formato a la zona izquierda del texto.
     */
    public final static int FORMAT_LABEL_A = 1;
    /**
     * Utilizado para formatear la Salida en una etiqueta. Label A indica
     * que se aplicará formato a la zona derecha del texto.
     */
    public final static int FORMAT_LABEL_B = 2;    
        
    /**
     * Crea un Nodo Simple para un Árbol.
     * @param strEtiqueta Etiqueta del Nodo.
     * @return Nodo.
     * @throws SecurityException
     */
    public static DefaultMutableTreeNode crearNodo(String strEtiqueta) throws SecurityException {
        return crearNodo(strEtiqueta, null);
    }   
        
    /**
     * Crea un Nodo Simple para un Árbol.
     * @param strEtiqueta Etiqueta del Nodo.
     * @param obj Objeto Incluido en el Nodo.
     * @return Nodo.
     * @throws SecurityException Exception de Seguridad.
     */
    public static DefaultMutableTreeNode crearNodo(String strEtiqueta, Object obj) throws SecurityException {
        return crearNodo(strEtiqueta, obj, null);
    }
        
    /**
     * Crea un Nodo con Icono.
     * @param strEtiqueta Etiqueta del Nodo.
     * @param obj Objeto Incluido.
     * @param strIcono Ruta del Icono.
     * @return Nodo.
     * @throws SecurityException Exception de Seguridad.
     */
    public static DefaultMutableTreeNode crearNodo(String strEtiqueta, Object obj, String strIcono) throws SecurityException {
        try {
            //Se agrega la Raíz del árbol
            return crearNodo(strEtiqueta, "", obj, null, GeneradorArbol.FORMAT_LABEL_NORMAL, false);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.ClassCastException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }
    
    /**
     * Crea un Nodo con Etiquetas de Color y formato.
     * @param strEtiquetaA Zona de etiqueta A.
     * @param strEtiquetaB Zona de Etiqueta B.
     * @param format opción de formato de zonas.
     * @return Nodo.
     * @throws SecurityException Exception de Seguridad.
     */
    public static DefaultMutableTreeNode crearNodo(String strEtiquetaA, String strEtiquetaB, int format) throws SecurityException {
        try {
            //Se agrega la Raíz del árbol
            //DefaultMutableTreeNode objNodo = new DefaultMutableTreeNode(new InformacionNodo(strEtiqueta, obj, strIcono));                
            //return objNodo;
            return crearNodo(strEtiquetaA, strEtiquetaB, null, null, format, true);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.ClassCastException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }
    
    /**
     * Crea un Nodo con Etiquetas con formato e Incluye un Objeto.
     * @param strEtiquetaA Zona de etiqueta A.
     * @param strEtiquetaB Zona de etiqueta B.
     * @param obj Objeto Incluido.
     * @param format opción de formato.
     * @return Nodo.
     * @throws SecurityException Exception de Seguridad.
     */
    public static DefaultMutableTreeNode crearNodo(String strEtiquetaA, String strEtiquetaB, Object obj, int format) throws SecurityException {
        try {
            //Se agrega la Raíz del árbol
            //DefaultMutableTreeNode objNodo = new DefaultMutableTreeNode(new InformacionNodo(strEtiqueta, obj, strIcono));                
            //return objNodo;
            return crearNodo(strEtiquetaA, strEtiquetaB, obj, null, format, true);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.ClassCastException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }
    
    /**
     * Crea un Nodo con icono y Etiquetas con formato e incluye un objeto.
     * @param strEtiquetaA Zona de etiqueta A.
     * @param strEtiquetaB Zona de etiqueta B.
     * @param obj Objeto Incluido.
     * @param strIcono Ruta del Icono.
     * @param format opción de formato.
     * @param separate indica la forma en la que se aplica el formato.
     * @return Nodo.
     * @throws SecurityException Exception de Seguridad.
     */
    public static DefaultMutableTreeNode crearNodo(String strEtiquetaA, String strEtiquetaB, Object obj, String strIcono, int format, boolean separate) throws SecurityException {
        try {
            if(strEtiquetaA == null){
                return null;
            }
            else if(strEtiquetaA.isEmpty()){
                return null;
            }
            //Se agrega la Raíz del árbol
            String strEtiqueta = "";                        
            switch(format){
                case GeneradorArbol.FORMAT_LABEL_NORMAL:                    
                    strEtiqueta = "<html>" + ((separate) ? strEtiquetaA + " : " + strEtiquetaB : strEtiquetaA + strEtiquetaB) + "</html>";                    
                    break;
                case GeneradorArbol.FORMAT_LABEL_A:
                    strEtiqueta = "<html>" + ((separate) ? 
                            UtilRender.formatHtml(strEtiquetaA, UtilRender.FONT_COLOR, "888888") + " : " + strEtiquetaB : 
                            UtilRender.formatHtml(strEtiquetaA, UtilRender.FONT_COLOR, "888888") + strEtiquetaB) + "</html>";
                    break;
                case GeneradorArbol.FORMAT_LABEL_B:
                    strEtiqueta = "<html>" + ((separate) ? 
                            strEtiquetaA + " : " + UtilRender.formatHtml(strEtiquetaB, UtilRender.FONT_COLOR, "888888") : 
                            strEtiquetaA + UtilRender.formatHtml(strEtiquetaB, UtilRender.FONT_COLOR, "888888")) + "</html>";
                    break;
            }
            DefaultMutableTreeNode objNodo = new DefaultMutableTreeNode(new InformacionNodo(strEtiqueta, obj, strIcono));                
            return objNodo;
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.ClassCastException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }    
    
    /**
     * Crea un Nodo con el Nombre de un Componente.
     * @param objComponente Componente que se incluirá en el Nodo.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearNodoName(Componente objComponente){
        try{
            return crearNodo(objComponente.getName(), objComponente);
        } catch (java.lang.NullPointerException ex) {
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        } 
        return null;
    }
    
    /**
     * Crea un Nodo para un Tipo de Dato.
     * @param objObjetoTipoDatoReflexion Tipo de Dato.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearNodoTipoDato(ObjetoTipoDatoReflexion objObjetoTipoDatoReflexion){       
        if(objObjetoTipoDatoReflexion == null){
            return null;
        }
        String strLabel = objObjetoTipoDatoReflexion.getStrClassPath();        
        if(objObjetoTipoDatoReflexion.contieneRepresentacionesGenericas()){
            strLabel = "<b>" + strLabel + "</b>";        
            String genericos = objObjetoTipoDatoReflexion.getClassTypesGenericOnly(false);
            strLabel += " [" + genericos + "]";            
        }
        return crearNodo(strLabel, objObjetoTipoDatoReflexion.getObjCaso().geteCaso().toString(), objObjetoTipoDatoReflexion, GeneradorArbol.FORMAT_LABEL_B);
    }
    
    /**
     * Crea un Nodo para el Classpath de la Representación del Componente.
     * @param objComponente Componente que contiene la Representación Gráfica.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearNodoClassPath(Componente objComponente){
        try{
            return crearNodoClassPath(objComponente.getStrClassPath(), "Control Swing");
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return null;
    }
       
    
    /**
     * Crea un Nodo para un Classpath con etiqueta.
     * @param strClassPath Classpath del tipo que representa.
     * @param label Etiqueta que se agregara a la descripción.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearNodoClassPath(String strClassPath, String label){
        return crearNodo(strClassPath, label, strClassPath, GeneradorArbol.FORMAT_LABEL_B);
    }

    /**
     * Crea un Nodo para un Componente Genérico.
     * @param objComponente Componente Genérico.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(Componente objComponente){
        if (objComponente instanceof ComponenteDistribuidor) {
            return crearEstructura((ComponenteDistribuidor) objComponente);
        }        
        else if (objComponente instanceof ComponenteGeneradoSimple) {                    
            return crearEstructura((ComponenteGeneradoSimple) objComponente);
        }
        return null;
    }
    
    /**
     * Crea un Nodo para un Componente Distribuidor.
     * @param objComponente Componente Distribuidor.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidor objComponente){
        if (objComponente instanceof ComponenteDistribuidorContenedor) {
            return crearEstructura((ComponenteDistribuidorContenedor) objComponente);
        }        
        else if (objComponente instanceof ComponenteDistribuidorIntegrador) {
            return crearEstructura((ComponenteDistribuidorIntegrador) objComponente);
        }        
        else if (objComponente instanceof ComponenteDistribuidorGenerador) {
            return crearEstructura((ComponenteDistribuidorGenerador) objComponente);
        }                     
        else if (objComponente instanceof ComponenteDistribuidorExtra) {
            return crearEstructura((ComponenteDistribuidorExtra) objComponente);
        } 
        else if (objComponente instanceof ComponenteDistribuidorModeloAsociado) {
            return crearEstructura((ComponenteDistribuidorModeloAsociado) objComponente);
        }
        else{
            DefaultMutableTreeNode nodoRaiz = crearNodo("No se ha Agregado un Componente");
            return nodoRaiz;
        }        
    }
    
    /**
     * Crea un Nodo para un Componente Contenedor.
     * @param objComponenteContenedor Componente Contenedor.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorContenedor objComponenteContenedor){            
        if (objComponenteContenedor instanceof ComponenteDistribuidorContenedorEspejo) {
            return crearEstructura((ComponenteDistribuidorContenedorEspejo) objComponenteContenedor);
        }
        else if (objComponenteContenedor instanceof ComponenteDistribuidorContenedorLibre) {
            return crearEstructura((ComponenteDistribuidorContenedorLibre) objComponenteContenedor);
        }
        return null;
    }
    
    /**
     * Crea un Nodo para un Componente Integrador.
     * @param objComponenteIntegrador Componente Integrador.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorIntegrador objComponenteIntegrador){            
        if (objComponenteIntegrador instanceof ComponenteDistribuidorIntegradorMetodo) {
            return crearEstructura((ComponenteDistribuidorIntegradorMetodo) objComponenteIntegrador);
        }
        else if (objComponenteIntegrador instanceof ComponenteDistribuidorIntegradorSimple) {
            return crearEstructura((ComponenteDistribuidorIntegradorSimple) objComponenteIntegrador);
        }
        else if (objComponenteIntegrador instanceof ComponenteDistribuidorIntegradorExtra) {
            return crearEstructura((ComponenteDistribuidorIntegradorExtra) objComponenteIntegrador);
        }
        return null;
    }
        
    /**
     * Crea un Nodo para un Componente Generador.
     * @param objComponenteGenerador Componente Generador.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGenerador objComponenteGenerador){            
        if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorClaseCompleja) {                
            return crearEstructura((ComponenteDistribuidorGeneradorClaseCompleja) objComponenteGenerador);                
        }
        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorMetodo) {                    
            return crearEstructura((ComponenteDistribuidorGeneradorMetodo) objComponenteGenerador);                    
        }            
        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorUnitario) {                
            return crearEstructura((ComponenteDistribuidorGeneradorUnitario) objComponenteGenerador);                
        }                        
        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorString) {                
            return crearEstructura((ComponenteDistribuidorGeneradorString) objComponenteGenerador);                
        }                        
        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorEnum) {                
            return crearEstructura((ComponenteDistribuidorGeneradorEnum) objComponenteGenerador);                
        }
        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorVinculador) {                
            return crearEstructura((ComponenteDistribuidorGeneradorVinculador) objComponenteGenerador);                
        } 
        return null;
    }

    /**
     * Devuelve el Arbol que representa el Componente.
     * @param strRaiz @DefinicionParametro
     * @param objComponente @DefinicionParametro
     * @return  @DefinicionReturn
     * @throws SecurityException @DefinicionExcepcion
     */
    public static DefaultMutableTreeNode crearEstructuraToRaizString(String strRaiz, Object objComponente) throws SecurityException {
        DefaultMutableTreeNode nodoRaiz = null;
        try {
            //Se agrega la Raíz del árbol
            nodoRaiz = crearNodo(strRaiz, objComponente);
            if (objComponente instanceof Componente) {
                nodoRaiz.add(crearEstructura((Componente) objComponente));
            }                 
            return nodoRaiz;
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.ClassCastException ex) {
            Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }
    
    /**
     * Crea la Estructura de Nodo que representa el Paquete.
     * @param objPaqueteParent Paquete que contiene la estructura que se Representará.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(PaqueteClass objPaqueteParent) {
        DefaultMutableTreeNode nodoPaquete = null;        
        if(objPaqueteParent == null){
            return null;
        }        
        nodoPaquete = 
                crearNodo(
                objPaqueteParent.getStrNombre(),
                objPaqueteParent
            );                   
        for(PaqueteClass objPaqueteHijo : objPaqueteParent.getObjHijos()){                            
            nodoPaquete.add(crearEstructura(objPaqueteHijo));               
        }               
        return nodoPaquete;
    }
    
    /**
     * Crea un Nodo para Representar la Estructura de Beans.
     * @param objComponentesBeans Colección de Beans.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructuraColeccionComponentesBeans(ArrayList<ComponenteBeans> objComponentesBeans) {        
        DefaultMutableTreeNode nodoComponenteBeans = null;        
        if(objComponentesBeans == null){
            return null;
        }        
        DefaultMutableTreeNode nodoComponentesBeans = crearNodo("Propiedades Compuestas");
        for (ComponenteBeans objComponenteBeans : objComponentesBeans) {                
            nodoComponenteBeans = crearEstructura(objComponenteBeans);
            nodoComponentesBeans.add(nodoComponenteBeans);                
        }
        return nodoComponentesBeans;
    }
    
    /**
     * Crea un Nodo para la Representar las Propiedades de un Beans.
     * @param objPropiedadesBeans Colección de Propiedades de un Beans.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructuraColeccionPropiedadesBeans(ArrayList<PropiedadBeans> objPropiedadesBeans) {        
        DefaultMutableTreeNode nodoPropiedadBeans = null;        
        if(objPropiedadesBeans == null){
            return null;
        }        
        DefaultMutableTreeNode nodoPropiedadesBeans = crearNodo("Propiedades Simples");
        for (PropiedadBeans objPropiedadBeans : objPropiedadesBeans) {                
            //String strClassPath = objPropiedadBeans.toString();
            //nodoPropiedadBeans = crearNodo(strClassPath, strClassPath);
            nodoPropiedadBeans = crearEstructura(objPropiedadBeans);
            nodoPropiedadesBeans.add(nodoPropiedadBeans);                
        }
        return nodoPropiedadesBeans;
    }    
    
    /**
     * Crea un Nodo para un Componente Beans.
     * @param objComponenteBeans Componente Beans.
     * @return Beans.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteBeans objComponenteBeans) {
        DefaultMutableTreeNode nodoPropiedadesBeans = null;
        DefaultMutableTreeNode nodoComponentesBeans = null;                
        DefaultMutableTreeNode nodoRaiz = null;        
        if(objComponenteBeans == null){
            return null;
        }        
        try{
            nodoRaiz = 
                    crearNodo(
                        objComponenteBeans.getName(), 
                        "Beans",
                        objComponenteBeans,
                        GeneradorArbol.FORMAT_LABEL_B);
            nodoPropiedadesBeans = crearEstructuraColeccionPropiedadesBeans(objComponenteBeans.getObjPropiedadesStaticSimpleBeans());
            nodoComponentesBeans = crearEstructuraColeccionComponentesBeans(objComponenteBeans.getObjPropiedadesStaticObjectBeans());
            nodoRaiz.add(nodoPropiedadesBeans);
            nodoRaiz.add(nodoComponentesBeans);            
        }catch(java.lang.Exception ex){
            nodoRaiz = crearNodo("No se ha Agregado un Componente Beans");
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);            
        }
        return nodoRaiz;
    }
    
    /**
     * Crea la Paleta de Controles disponibles para generar representaciones en la herramienta.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructuraPaleta() {
        DefaultMutableTreeNode nodoRaiz = null;
        DefaultMutableTreeNode nodoComponentesBase = null;  
        DefaultMutableTreeNode nodoContenedoresBase = null;  
        DefaultMutableTreeNode nodoComponentesBasePersonalizados = null;          
        nodoRaiz = crearNodo("Paleta Swing");
        nodoComponentesBase = crearEstructuraColeccionComponentesBaseStandar();
        nodoContenedoresBase = crearEstructuraColeccionContenedoresBaseStandar();
        nodoComponentesBasePersonalizados = crearEstructuraColeccionComponentesBasePersonalizados();
        nodoRaiz.add(nodoComponentesBase);
        nodoRaiz.add(nodoContenedoresBase);
        nodoRaiz.add(nodoComponentesBasePersonalizados);
        return nodoRaiz;
    }
    
    /**
     * Crea un Nodo para la Colección de Componentes Base Standard.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructuraColeccionComponentesBaseStandar() {
        DefaultMutableTreeNode nodoComponentesStandard = null;  
        DefaultMutableTreeNode nodoComponenteStandard = null;  
        nodoComponentesStandard = crearNodo("Controles");        
        try{
            for (ComponenteBaseStandar objComponenteBase : GeneradorComponentes.objComponentesBase) {
                    nodoComponenteStandard = crearEstructura(objComponenteBase);
                    nodoComponentesStandard.add(nodoComponenteStandard);
            }
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoComponentesStandard;
    }
    
    /**
     * Crea un Nodo para la Colección de Componentes Contenedores Standard.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructuraColeccionContenedoresBaseStandar() {
        DefaultMutableTreeNode nodoComponentesStandard = null;  
        DefaultMutableTreeNode nodoComponenteStandard = null;  
        nodoComponentesStandard = crearNodo("Contenedores");
        try{
            for (ComponenteBaseStandar objComponenteBase : GeneradorComponentes.objContenedoresBase) {
                nodoComponenteStandard = crearEstructura(objComponenteBase);
                nodoComponentesStandard.add(nodoComponenteStandard);
            }
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoComponentesStandard;
    }
    
    /**
     * Crea un Nodo para la Colección de Componentes Base Personalizados.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructuraColeccionComponentesBasePersonalizados() {
        DefaultMutableTreeNode nodoComponentesBasePersonalizados = null;  
        DefaultMutableTreeNode nodoComponenteBasePersonalizado = null;  
        nodoComponentesBasePersonalizados = crearNodo("Personalizados");
        try{
            for (ComponenteBasePersonalizado objComponenteBasePersonalizado : GeneradorComponentes.objComponentesPersonalizadosBase) {
                nodoComponenteBasePersonalizado = crearEstructura(objComponenteBasePersonalizado);
                nodoComponentesBasePersonalizados.add(nodoComponenteBasePersonalizado);
            }
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoComponentesBasePersonalizados;
    }
    
    private static DefaultMutableTreeNode crearEstructura(ComponenteBasePersonalizado objComponenteBasePersonalizado) {
        DefaultMutableTreeNode nodoComponenteBase;        
        try{
            nodoComponenteBase = 
                    crearNodo(
                        objComponenteBasePersonalizado.getStrAlias(),
                        "Grupo Swing",
                        objComponenteBasePersonalizado,
                        GeneradorArbol.FORMAT_LABEL_B
                    );          
            
        }catch(java.lang.Exception ex){
            nodoComponenteBase =
                    crearNodo("No ha Creado un Componente Generado");
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoComponenteBase;
    }
    
    private static DefaultMutableTreeNode crearEstructura(ComponenteBaseStandar objComponenteBase) {
        DefaultMutableTreeNode nodoComponenteBase;
        try{
            nodoComponenteBase = 
                    crearNodo(
                        objComponenteBase.getStrClassPath(),
                        "Control Swing",
                        objComponenteBase,
                        GeneradorArbol.FORMAT_LABEL_B
                    );
        }catch(java.lang.Exception ex){
            nodoComponenteBase =
                    crearNodo("No ha Creado un Componente Generado");
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoComponenteBase;
    }
    
    private static DefaultMutableTreeNode crearEstructura(PropiedadBeans objPropiedadBeans) {
        DefaultMutableTreeNode nodoPropiedadBeans;        
        DefaultMutableTreeNode nodoNamePropiedadBeans; 
        DefaultMutableTreeNode nodoClassPathPropiedadBeans;         
        try{
            nodoPropiedadBeans = 
                    crearNodo(
                        objPropiedadBeans.getStrOnlyName(),
                        "Propiedad Beans",
                        objPropiedadBeans, 
                        GeneradorArbol.FORMAT_LABEL_B
                    );            
           nodoNamePropiedadBeans = 
                   crearNodo(
                        objPropiedadBeans.getObjPropiedadBase().getName(), 
                        "Propiedad Base",
                        objPropiedadBeans.getObjPropiedadBase().getName(), 
                        GeneradorArbol.FORMAT_LABEL_B
                   );            
           nodoClassPathPropiedadBeans = 
                   crearNodo(
                        objPropiedadBeans.getStrClassPathParametroDefaul(), 
                        "ClassPath",
                        objPropiedadBeans.getStrClassPathParametroDefaul(),
                        GeneradorArbol.FORMAT_LABEL_B
                   );            
           nodoPropiedadBeans.add(nodoNamePropiedadBeans);
           nodoPropiedadBeans.add(nodoClassPathPropiedadBeans);            
        }catch(java.lang.Exception ex){
            nodoPropiedadBeans =
                    crearNodo("No ha Creado una Propiedad Beans.");
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoPropiedadBeans;
    }
    

    private static DefaultMutableTreeNode crearEstructura(ComponenteGeneradoSimple objComponenteGeneradoSimple) {
        DefaultMutableTreeNode nodoComponenteGenerado;
        DefaultMutableTreeNode nodoClassPathComponente;        
        try{
            nodoComponenteGenerado = 
                    crearNodoName(objComponenteGeneradoSimple);
            
            if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                nodoClassPathComponente = 
                    crearNodoClassPath(objComponenteGeneradoSimple);            
                nodoComponenteGenerado.add(nodoClassPathComponente);
                nodoComponenteGenerado.add(crearEstructura(objComponenteGeneradoSimple.getObjPropiedadBeans()));                
            }            
        }catch(java.lang.Exception ex){
            nodoComponenteGenerado =
                    crearNodo("No ha Creado un Componente Generado");
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoComponenteGenerado;
    }
        
    private static DefaultMutableTreeNode crearEstructura(ComponenteGeneradoInterno objComponenteGeneradoInterno) {
        DefaultMutableTreeNode nodoComponenteGenerado;
        DefaultMutableTreeNode nodoClassPathComponente;        
        try{        
            nodoComponenteGenerado = 
                    crearNodoName(objComponenteGeneradoInterno);
            
            if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){

                nodoClassPathComponente = 
                        crearNodoClassPath(objComponenteGeneradoInterno);

                nodoComponenteGenerado.add(nodoClassPathComponente);
                nodoComponenteGenerado.add(crearEstructura(objComponenteGeneradoInterno.getObjPropiedadBeans()));
            }            
        }catch(java.lang.Exception ex){
            nodoComponenteGenerado =
                    crearNodo("No ha Creado un Componente Generado");
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoComponenteGenerado;
    }
        
    /**
     * Crea un Nodo con la Estructura de un Componente Clase Compleja.
     * @param objComponenteGeneradorClase Componente Clase.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorClaseCompleja objComponenteGeneradorClase) {
        DefaultMutableTreeNode nodoComponenteGenerador = null;
        DefaultMutableTreeNode nodoComponenteGenerado = null;
        DefaultMutableTreeNode nodoAtributos = null;
        DefaultMutableTreeNode nodoMetodos = null;            
        DefaultMutableTreeNode nodoComponentesGenerados = null;
        
        if(objComponenteGeneradorClase == null){
            return null;
        }
        
        //Crear Nodo Raíz
        DefaultMutableTreeNode nodoRaiz = 
                crearNodoName(objComponenteGeneradorClase);        
        
        if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
            for (Componente objComponente : objComponenteGeneradorClase.getObjComponentes()) {
                if(objComponente instanceof ComponenteDistribuidorGenerador){
                    ComponenteDistribuidorGenerador objComponenteDistribuidorGenerador = (ComponenteDistribuidorGenerador) objComponente;
                    GeneradorArbol.crearEstructura(nodoRaiz, objComponenteDistribuidorGenerador);
                }                                 
            }
            if(!objComponenteGeneradorClase.getObjComponentesGenerados().isEmpty()){
                GeneradorArbol.crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteGeneradorClase.getObjComponentesGenerados());
            }
        }
        else{                    
            
            nodoAtributos = crearNodo("Atributos");
            nodoMetodos = crearNodo("Metodos");                        

            nodoRaiz.add(nodoAtributos);
            nodoRaiz.add(nodoMetodos);    

            //Se crea el bucle para extraer todos los componentes agregados (generadores, extras)
            for (Componente objComponente : objComponenteGeneradorClase.getObjComponentes()) {
                if (objComponente instanceof ComponenteDistribuidorGeneradorClaseCompleja) {
                    ComponenteDistribuidorGeneradorClaseCompleja objComponenteGenerador = (ComponenteDistribuidorGeneradorClaseCompleja) objComponente;
                    nodoComponenteGenerador = GeneradorArbol.crearEstructura(objComponenteGenerador);
                    nodoAtributos.add(nodoComponenteGenerador);
                } 
                else if (objComponente instanceof ComponenteDistribuidorGeneradorMetodo) {
                    ComponenteDistribuidorGeneradorMetodo objComponenteGenerador = (ComponenteDistribuidorGeneradorMetodo) objComponente;
                    nodoComponenteGenerador = GeneradorArbol.crearEstructura(objComponenteGenerador);
                    nodoMetodos.add(nodoComponenteGenerador);
                }                    
                else if (objComponente instanceof ComponenteDistribuidorGeneradorEnum) {
                    ComponenteDistribuidorGeneradorEnum objComponenteGenerador = (ComponenteDistribuidorGeneradorEnum) objComponente;
                    nodoComponenteGenerador = GeneradorArbol.crearEstructura(objComponenteGenerador);
                    nodoAtributos.add(nodoComponenteGenerador);
                }               
                else if (objComponente instanceof ComponenteDistribuidorGeneradorVinculador) {
                    ComponenteDistribuidorGeneradorVinculador objComponenteGenerador = (ComponenteDistribuidorGeneradorVinculador) objComponente;
                    nodoComponenteGenerador = GeneradorArbol.crearEstructura(objComponenteGenerador);
                    nodoAtributos.add(nodoComponenteGenerador);
                }               
                else if (objComponente instanceof ComponenteDistribuidorGeneradorUnitario) {
                    ComponenteDistribuidorGeneradorUnitario objComponenteGenerador = (ComponenteDistribuidorGeneradorUnitario) objComponente;
                    nodoComponenteGenerador = GeneradorArbol.crearEstructura(objComponenteGenerador);
                    nodoAtributos.add(nodoComponenteGenerador);
                }
                else if (objComponente instanceof ComponenteDistribuidorGeneradorString) {
                    ComponenteDistribuidorGeneradorString objComponenteGenerador = (ComponenteDistribuidorGeneradorString) objComponente;
                    nodoComponenteGenerador = GeneradorArbol.crearEstructura(objComponenteGenerador);
                    nodoAtributos.add(nodoComponenteGenerador);
                }
                else if (objComponente instanceof ComponenteGeneradoSimple) {
                    ComponenteGeneradoSimple objComponenteGenerado = (ComponenteGeneradoSimple) objComponente;
                    nodoComponenteGenerado = GeneradorArbol.crearEstructura(objComponenteGenerado);
                    nodoComponentesGenerados.add(nodoComponenteGenerado);
                }
            }       
            
            nodoComponentesGenerados = crearNodo("Componentes Generados");
            //Aqui se agregan los posibles componentes generados            
            ArrayList<ComponenteGeneradoSimple> objComponentesGenerados = objComponenteGeneradorClase.getObjComponentesGenerados();
            nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponentesGenerados);
            nodoRaiz.add(nodoComponentesGenerados);  
        }
        
        if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
            ComponenteBeans objComponenteBeans = objComponenteGeneradorClase.getObjComponenteBeans();
            if(objComponenteBeans != null){
                DefaultMutableTreeNode nodoComponenteBeans = crearEstructura(objComponenteBeans);
                nodoRaiz.add(nodoComponenteBeans);
            }
        }
        return nodoRaiz;
    }            
    
    /**
     * Crea un Nodo para una Colección de Tipos de Datos.
     * @param objRaizParent Raiz del Arbol Contenedor.
     * @param objColeccion Colección de Tipos de Datos.
     */
    public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ArrayList<ObjetoReflexion> objColeccion){
        try{
            for(ObjetoReflexion obj : objColeccion){
                DefaultMutableTreeNode objMetodo = crearEstructura(obj);
                objRaizParent.add(objMetodo);
            }
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
    }
    
    /**
     * Crea un Nodo para un Componente Distribuidor que se incluira en un Raiz de un Árbol.
     * @param objRaizParent Nodo Raíz.
     * @param objComponente Componente Distribuidor.
     */
    public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidor objComponente){
       
        if (objComponente instanceof ComponenteDistribuidorContenedor) {
            crearEstructura(objRaizParent, (ComponenteDistribuidorContenedor) objComponente);
        }        
        else if (objComponente instanceof ComponenteDistribuidorIntegrador) {
            crearEstructura(objRaizParent, (ComponenteDistribuidorIntegrador) objComponente);
        }        
        else if (objComponente instanceof ComponenteDistribuidorGenerador) {
            crearEstructura(objRaizParent, (ComponenteDistribuidorGenerador) objComponente);
        }                     
        else if (objComponente instanceof ComponenteDistribuidorExtra) {
            crearEstructura(objRaizParent, (ComponenteDistribuidorExtra) objComponente);
        } 
        else if (objComponente instanceof ComponenteDistribuidorModeloAsociado) {
            crearEstructura(objRaizParent, (ComponenteDistribuidorModeloAsociado) objComponente);
        }                
    }
    
    /**
     * Crea un Nodo para un Componente Contenedor que se incluira en un Raiz de un Árbol.
     * @param objRaizParent Nodo Raíz.
     * @param objComponenteContenedor Componente Contenedor. 
     */
    public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorContenedor objComponenteContenedor){            
        if (objComponenteContenedor instanceof ComponenteDistribuidorContenedorEspejo) {
            //return crearEstructura((ComponenteDistribuidorContenedorEspejo) objComponenteContenedor);
        }
        else if (objComponenteContenedor instanceof ComponenteDistribuidorContenedorLibre) {
            //return crearEstructura((ComponenteDistribuidorContenedorLibre) objComponenteContenedor);
        }        
    }
    
    /**
     * Crea un Nodo para un Componente Integrador que se incluira en un Raiz de un Árbol.
     * @param objRaizParent Nodo Raíz.
     * @param objComponenteIntegrador Componente Integrador.
     */
    public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorIntegrador objComponenteIntegrador){            
        if (objComponenteIntegrador instanceof ComponenteDistribuidorIntegradorMetodo) {
            //return crearEstructura((ComponenteDistribuidorIntegradorMetodo) objComponenteIntegrador);
        }
        else if (objComponenteIntegrador instanceof ComponenteDistribuidorIntegradorSimple) {
            //return crearEstructura((ComponenteDistribuidorIntegradorSimple) objComponenteIntegrador);
        }
        else if (objComponenteIntegrador instanceof ComponenteDistribuidorIntegradorExtra) {
            //return crearEstructura((ComponenteDistribuidorIntegradorExtra) objComponenteIntegrador);
        }        
    }    
    
    /**
     * Crea un Nodo para un Componente Generador que se incluira en un Raiz de un Árbol.
     * @param objRaizParent Nodo Raíz.
     * @param objComponenteGenerador Componente Generador.
     */
    public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGenerador objComponenteGenerador) {    
        if(objComponenteGenerador instanceof ComponenteDistribuidorGeneradorMetodo){
            ComponenteDistribuidorGeneradorMetodo objComponenteDistribuidorGeneradorMetodo = (ComponenteDistribuidorGeneradorMetodo) objComponenteGenerador;
            GeneradorArbol.crearEstructura(objRaizParent, objComponenteDistribuidorGeneradorMetodo);
        }
        else if(objComponenteGenerador instanceof ComponenteDistribuidorGeneradorUnitario){
            ComponenteDistribuidorGeneradorUnitario objComponenteDistribuidorGeneradorUnitario = (ComponenteDistribuidorGeneradorUnitario) objComponenteGenerador;
            DefaultMutableTreeNode nodoComponenteGenerador = crearNodoName(objComponenteDistribuidorGeneradorUnitario);
            GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteDistribuidorGeneradorUnitario);
            objRaizParent.add(nodoComponenteGenerador);            
        }
        else if(objComponenteGenerador instanceof ComponenteDistribuidorGeneradorString){
            ComponenteDistribuidorGeneradorString objComponenteDistribuidorGeneradorString = (ComponenteDistribuidorGeneradorString) objComponenteGenerador;
            DefaultMutableTreeNode nodoComponenteGenerador = crearNodoName(objComponenteDistribuidorGeneradorString);
            GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteDistribuidorGeneradorString);
            objRaizParent.add(nodoComponenteGenerador);            
        }
        else if(objComponenteGenerador instanceof ComponenteDistribuidorGeneradorEnum){
            ComponenteDistribuidorGeneradorEnum objComponenteDistribuidorGeneradorEnum = (ComponenteDistribuidorGeneradorEnum) objComponenteGenerador;
            GeneradorArbol.crearEstructura(objRaizParent, objComponenteDistribuidorGeneradorEnum);
        }
        else if(objComponenteGenerador instanceof ComponenteDistribuidorGeneradorVinculador){
            ComponenteDistribuidorGeneradorVinculador objComponenteDistribuidorGeneradorVinculador = (ComponenteDistribuidorGeneradorVinculador) objComponenteGenerador;
            DefaultMutableTreeNode nodoComponenteGenerador = crearNodoName(objComponenteDistribuidorGeneradorVinculador);
            GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteDistribuidorGeneradorVinculador);
            objRaizParent.add(nodoComponenteGenerador);            
        }
        else if(objComponenteGenerador instanceof ComponenteDistribuidorGeneradorClaseCompleja){
            ComponenteDistribuidorGeneradorClaseCompleja objComponenteDistribuidorGeneradorClase = (ComponenteDistribuidorGeneradorClaseCompleja) objComponenteGenerador;
            GeneradorArbol.crearEstructura(objRaizParent, objComponenteDistribuidorGeneradorClase);
        }
    }
    
    /**
     * Crea un Nodo para un Componente Generador Clase que se incluira en un Raiz de un Árbol.
     * @param objRaizParent Nodo Raíz.
     * @param objComponenteGeneradorClase Componente Generador Clase.
     */
    public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorClaseCompleja objComponenteGeneradorClase) {    
        try{
            //Crear Nodo Raíz
            DefaultMutableTreeNode nodoRaiz = 
                    crearNodoName(objComponenteGeneradorClase);        

            for (Componente objComponente : objComponenteGeneradorClase.getObjComponentes()) {
                if(objComponente instanceof ComponenteDistribuidorGenerador){
                    ComponenteDistribuidorGenerador objComponenteDistribuidorGenerador = (ComponenteDistribuidorGenerador) objComponente;
                    GeneradorArbol.crearEstructura(nodoRaiz, objComponenteDistribuidorGenerador);
                }                
            }

            if(!objComponenteGeneradorClase.getObjComponentesGenerados().isEmpty()){
                GeneradorArbol.crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteGeneradorClase.getObjComponentesGenerados());
            }

            if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        

                ComponenteBeans objComponenteBeans = objComponenteGeneradorClase.getObjComponenteBeans();
                if(objComponenteBeans != null){
                    DefaultMutableTreeNode nodoComponenteBeans = crearEstructura(objComponenteBeans);
                    nodoRaiz.add(nodoComponenteBeans);
                }
            }
            objRaizParent.add(nodoRaiz);        
        }catch(java.lang.Exception ex){
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
    }        
        
    /**
     * Crea un Nodo con la Estructura de Representación de un Componente Integrador Método.
     * @param objComponenteIntegradorMetodo Componente integrador Método.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorIntegradorMetodo objComponenteIntegradorMetodo) {
        try{
            DefaultMutableTreeNode nodoValorRetorno = null;
            DefaultMutableTreeNode nodoParametros = null;
            DefaultMutableTreeNode nodoComponentesGenerados = null;
            DefaultMutableTreeNode nodoComponenteGenerador = null;  
            DefaultMutableTreeNode nodoComponenteBeans = null; 

            //Configurando Raíz
            DefaultMutableTreeNode nodoRaiz =
                    crearNodoName(objComponenteIntegradorMetodo);

            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                for (Componente objComponente : objComponenteIntegradorMetodo.getComponentesDistribuidos()) {
                    if(objComponente instanceof ComponenteDistribuidorGenerador){
                        ComponenteDistribuidorGenerador objComponenteDistribuidorGenerador = (ComponenteDistribuidorGenerador) objComponente;
                        GeneradorArbol.crearEstructura(nodoRaiz, objComponenteDistribuidorGenerador);
                    }                                 
                }
                if(!objComponenteIntegradorMetodo.getObjComponentesGenerados().isEmpty()){
                    GeneradorArbol.crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteIntegradorMetodo.getObjComponentesGenerados());
                }
                if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                    ComponenteBeans objComponenteBeans = objComponenteIntegradorMetodo.getObjComponenteBeans();
                    if(objComponenteBeans != null){
                        nodoComponenteBeans = crearEstructura(objComponenteBeans);
                        nodoRaiz.add(nodoComponenteBeans);
                    }
                }
            }
            else{
                
                //Configurando Carpetas
                nodoValorRetorno = crearNodo("Valor de Retorno");
                nodoParametros = crearNodo("Parametro");

                DefaultMutableTreeNode nodoObjetoReflexion = crearEstructura(objComponenteIntegradorMetodo.getObjReflexion());
                nodoRaiz.add(nodoObjetoReflexion);

                DefaultMutableTreeNode nodoComponenteGeneradorReturn =
                        GeneradorArbol.crearEstructura(objComponenteIntegradorMetodo.getObjComponenteReturn());
                nodoValorRetorno.add(nodoComponenteGeneradorReturn);
                nodoRaiz.add(nodoValorRetorno);

                nodoRaiz.add(nodoParametros);
                //Se crea el bucle para extraer todos los componentes agregados (generadores, extras)
                for (Componente objComponenteGenerador : objComponenteIntegradorMetodo.getObjComponentesDistribuidores()) {
                                        
                    nodoComponenteGenerador = crearEstructura(objComponenteGenerador);
                    nodoParametros.add(nodoComponenteGenerador);                    
                }

                //Aqui se agregan los posibles componentes generados            
                ArrayList<ComponenteGeneradoSimple> objComponentesGenerados = objComponenteIntegradorMetodo.getObjComponentesGenerados();
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponentesGenerados);
                nodoRaiz.add(nodoComponentesGenerados); 

                if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                    ComponenteBeans objComponenteBeans = objComponenteIntegradorMetodo.getObjComponenteBeans();
                    if(objComponenteBeans != null){
                        nodoComponenteBeans = crearEstructura(objComponenteBeans);
                        nodoRaiz.add(nodoComponenteBeans);
                    }
                }
            }

            return nodoRaiz;
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return null;
    }        
    
    /**
     * Crea un Nodo con la Estructura de Representación de un Componente Integrador Simple.
     * @param ComponenteDistribuidorIntegradorSimple Componente integrador Simple.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorIntegradorSimple objComponenteIntegradorSimple) {
        try{
            DefaultMutableTreeNode nodoParametros = null;
            DefaultMutableTreeNode nodoComponentesGenerados = null;
            DefaultMutableTreeNode nodoComponenteGenerador = null;  
            DefaultMutableTreeNode nodoComponenteBeans = null;  

            //Configurando Raíz
                DefaultMutableTreeNode nodoRaiz =
                        crearNodoName(objComponenteIntegradorSimple);        

            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                for (Componente objComponente : objComponenteIntegradorSimple.getObjComponentesDistribuidores()) {
                    if(objComponente instanceof ComponenteDistribuidorGenerador){
                        ComponenteDistribuidorGenerador objComponenteDistribuidorGenerador = (ComponenteDistribuidorGenerador) objComponente;
                        GeneradorArbol.crearEstructura(nodoRaiz, objComponenteDistribuidorGenerador);
                    }                                 
                }
                if(!objComponenteIntegradorSimple.getObjComponentesGenerados().isEmpty()){
                    GeneradorArbol.crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteIntegradorSimple.getObjComponentesGenerados());
                }
                if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                    ComponenteBeans objComponenteBeans = objComponenteIntegradorSimple.getObjComponenteBeans();
                    if(objComponenteBeans != null){
                        nodoComponenteBeans = crearEstructura(objComponenteBeans);
                        nodoRaiz.add(nodoComponenteBeans);
                    }
                }
            }
            else{

                //Configurando Carpetas
                nodoParametros = crearNodo("Parametro");

                nodoRaiz.add(nodoParametros);
                //Se crea el bucle para extraer todos los componentes agregados (generadores, extras)
                for (Componente objComponenteGenerador : objComponenteIntegradorSimple.getObjComponentesDistribuidores()) {
                    if(objComponenteGenerador != null){
                        nodoComponenteGenerador = crearEstructura(objComponenteGenerador);
                        nodoParametros.add(nodoComponenteGenerador);
                    }
                }

                //Aqui se agregan los posibles componentes generados            
                ArrayList<ComponenteGeneradoSimple> objComponentesGenerados = objComponenteIntegradorSimple.getObjComponentesGenerados();
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponentesGenerados);
                nodoRaiz.add(nodoComponentesGenerados); 

                if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                    ComponenteBeans objComponenteBeans = objComponenteIntegradorSimple.getObjComponenteBeans();
                    if(objComponenteBeans != null){
                        nodoComponenteBeans = crearEstructura(objComponenteBeans);
                        nodoRaiz.add(nodoComponenteBeans);
                    }
                }
            }

            return nodoRaiz;
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Error Objeto Nulo.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return null;
   }
    
    /**
     * Crea un Nodo con la Estructura de Representación de un Componente Integrador Extra.
     * @param ComponenteDistribuidorIntegradorExtra Componente integrador Extra.
     * @return Nodo.
     */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorIntegradorExtra objComponenteIntegradorExtra) {        
        DefaultMutableTreeNode nodoComponentesExtras = null;
        DefaultMutableTreeNode nodoComponentesGenerados = null;
        DefaultMutableTreeNode nodoComponenteExtra = null;            
        DefaultMutableTreeNode nodoRaiz = null;
        DefaultMutableTreeNode nodoComponenteBeans = null;        

        try{
            
            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                for (Componente objComponente : objComponenteIntegradorExtra.getObjComponentesDistribuidores()) {
                    if(objComponente instanceof ComponenteDistribuidorGenerador){
                        ComponenteDistribuidorGenerador objComponenteDistribuidorGenerador = (ComponenteDistribuidorGenerador) objComponente;
                        GeneradorArbol.crearEstructura(nodoRaiz, objComponenteDistribuidorGenerador);
                    }                                 
                }
                if(!objComponenteIntegradorExtra.getObjComponentesGenerados().isEmpty()){
                    GeneradorArbol.crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteIntegradorExtra.getObjComponentesGenerados());
                }
                if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                    ComponenteBeans objComponenteBeans = objComponenteIntegradorExtra.getObjComponenteBeans();
                    if(objComponenteBeans != null){
                        nodoComponenteBeans = crearEstructura(objComponenteBeans);
                        nodoRaiz.add(nodoComponenteBeans);
                    }
                }
            }
            else{
                //Configurando Carpetas
                nodoComponentesExtras = crearNodo("Componentes Extras");

                //Configurando Raíz
                nodoRaiz =
                        crearNodoName(objComponenteIntegradorExtra);        

                nodoRaiz.add(nodoComponentesExtras);
                //Se crea el bucle para extraer todos los componentes agregados (generadores, extras)
                for (Componente objComponenteExtra : objComponenteIntegradorExtra.getObjComponentesDistribuidores()) {
                    if(objComponenteExtra != null){
                        nodoComponenteExtra = crearEstructura(objComponenteExtra);
                        nodoComponentesExtras.add(nodoComponenteExtra);
                    }
                }

                //Aqui se agregan los posibles componentes generados            
                ArrayList<ComponenteGeneradoSimple> objComponentesGenerados = objComponenteIntegradorExtra.getObjComponentesGenerados();
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponentesGenerados);
                nodoRaiz.add(nodoComponentesGenerados);  

                ComponenteBeans objComponenteBeans = objComponenteIntegradorExtra.getObjComponenteBeans();
                if(objComponenteBeans != null){
                    nodoComponenteBeans = crearEstructura(objComponenteBeans);
                    nodoRaiz.add(nodoComponenteBeans);
                }
            }
            
        }catch(java.lang.Exception ex){
            nodoRaiz = crearNodo("No se ha Agregado el Componente.");        
            UtilRender.printlnConsole("Error Desconocido.", ex.getMessage(), UtilRender.ACTION_ERROR);
        }
        return nodoRaiz;
    }
    
        /**
	 * @DefinicionMetodo
     * @param objRaizParent 
     * @param objComponenteContenedor @DefinicionParametro
@DefinicionReturn
	 */
	public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorMetodo objComponenteContenedor) {            
            try{
                DefaultMutableTreeNode nodoRaiz =
                        crearNodoName(objComponenteContenedor);
                if(objComponenteContenedor.geteMetodo() == TipoMetodo.eGetter){
                    GeneradorArbol.crearEstructura(nodoRaiz, (ComponenteDistribuidorGeneradorMetodoGetter)objComponenteContenedor);
                }
                else if(objComponenteContenedor.geteMetodo() == TipoMetodo.eSetter){
                    GeneradorArbol.crearEstructura(nodoRaiz,(ComponenteDistribuidorGeneradorMetodoSetter)objComponenteContenedor);
                }                        
                objRaizParent.add(nodoRaiz);
            }catch(java.lang.NullPointerException ex){}
	}

	/**
	 * @DefinicionMetodo
	 * @param objComponenteContenedor @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorMetodo objComponenteContenedor) {
          try{
                if(objComponenteContenedor.geteMetodo() == TipoMetodo.eGetter){
                    return GeneradorArbol.crearEstructura((ComponenteDistribuidorGeneradorMetodoGetter)objComponenteContenedor);
                }
                else if(objComponenteContenedor.geteMetodo() == TipoMetodo.eSetter){
                    return GeneradorArbol.crearEstructura((ComponenteDistribuidorGeneradorMetodoSetter)objComponenteContenedor);
                }            
                return null;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
	 * Crear una Estructura en Árbol de un <code>ComponenteDistribuidorGeneradorMetodoGetter</code>.
	 * @param objComponenteGeneradorMetodo Componente por el cual se Generará la Estructura.
	 * @return Nodo Raíz de la Estructura que Representa el <code>ComponenteDistribuidorGeneradorMetodoGetter</code>.
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorMetodoGetter objComponenteGeneradorMetodo) {	            
          try{
                DefaultMutableTreeNode nodoComponenteGeneradorReturn = null;
                DefaultMutableTreeNode nodoReturn = null;            
                DefaultMutableTreeNode nodoComponentesGenerados = null;

                DefaultMutableTreeNode nodoRaiz =
                        crearNodoName(objComponenteGeneradorMetodo);

                if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                    ComponenteDistribuidorGenerador objComponenteGeneradorReturn = objComponenteGeneradorMetodo.getObjComponenteGeneradorReturn();
                    crearEstructura(nodoRaiz, objComponenteGeneradorReturn);                

                    if(!objComponenteGeneradorMetodo.getObjComponentesGenerados().isEmpty()){
                        crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteGeneradorMetodo.getObjComponentesGenerados());                    
                    }
                }
                else{

                    nodoReturn = crearNodo("Valor de Retorno");
                    ComponenteDistribuidorGenerador objComponenteGeneradorReturn = objComponenteGeneradorMetodo.getObjComponenteGeneradorReturn();
                    nodoComponenteGeneradorReturn = crearEstructura(objComponenteGeneradorReturn);
                    nodoReturn.add(nodoComponenteGeneradorReturn);
                    nodoRaiz.add(nodoReturn);            

                    nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteGeneradorMetodo.getObjComponentesGenerados());
                    nodoRaiz.add(nodoComponentesGenerados);
                }

                return nodoRaiz;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
	 * Crear una Estructura en Árbol de un <code>ComponenteDistribuidorGeneradorMetodoSetter</code>.
	 * @param objComponenteGeneradorMetodo Componente por el cual se Generará la Estructura.
	 * @return Nodo Raíz de la Estructura que Representa el <code>ComponenteDistribuidorGeneradorMetodoSetter</code>.
	 */
        public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorMetodoSetter objComponenteGeneradorMetodo) {	
         try{
                //Nodos Utilizados.            
                DefaultMutableTreeNode nodoComponenteGeneradorParametro = null;
                DefaultMutableTreeNode nodoParametro = null;            
                DefaultMutableTreeNode nodoComponentesGenerados = null;

                //Configuración del Nodo Raíz.
                DefaultMutableTreeNode nodoRaiz =
                        crearNodoName(objComponenteGeneradorMetodo);

                if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                    ComponenteDistribuidorGenerador objComponenteGeneradorParametro = objComponenteGeneradorMetodo.getObjComponenteGeneradorParam();            
                    crearEstructura(nodoRaiz, objComponenteGeneradorParametro);                                

                    if(!objComponenteGeneradorMetodo.getObjComponentesGenerados().isEmpty()){
                        crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteGeneradorMetodo.getObjComponentesGenerados());                    
                    }
                }
                else{
                    //Configuración del Nodo que representa el Parámetro.
                    nodoParametro = crearNodo("Parametro");
                    ComponenteDistribuidorGenerador objComponenteGeneradorParametro = objComponenteGeneradorMetodo.getObjComponenteGeneradorParam();            
                    nodoComponenteGeneradorParametro = crearEstructura(objComponenteGeneradorParametro);
                    nodoParametro.add(nodoComponenteGeneradorParametro);
                    nodoRaiz.add(nodoParametro);

                    nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteGeneradorMetodo.getObjComponentesGenerados());
                    nodoRaiz.add(nodoComponentesGenerados);
                }

                return nodoRaiz;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
         * 
         * @param objRaizParent
         * @param objComponenteGeneradorMetodo
         */
        public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorMetodoGetter objComponenteGeneradorMetodo) {	
            try{
                ComponenteDistribuidorGenerador objComponenteGeneradorReturn = objComponenteGeneradorMetodo.getObjComponenteGeneradorReturn();
                if(objComponenteGeneradorReturn instanceof ComponenteDistribuidorGeneradorUnitario){
                    GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorUnitario) objComponenteGeneradorReturn);
                }
                else if(objComponenteGeneradorReturn instanceof ComponenteDistribuidorGeneradorString){
                    GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorString) objComponenteGeneradorReturn);
                }
                else if(objComponenteGeneradorReturn instanceof ComponenteDistribuidorGeneradorEnum){
                    GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorEnum) objComponenteGeneradorReturn);
                }
                else if(objComponenteGeneradorReturn instanceof ComponenteDistribuidorGeneradorVinculador){
                    GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorVinculador) objComponenteGeneradorReturn);
                }
                else if(objComponenteGeneradorReturn instanceof ComponenteDistribuidorGeneradorClaseCompleja){
                    GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorClaseCompleja) objComponenteGeneradorReturn);
                }
                if(!objComponenteGeneradorMetodo.getObjComponentesGenerados().isEmpty()){
                    GeneradorArbol.crearEstructuraColeccionComponentesGenerados(objRaizParent, objComponenteGeneradorMetodo.getObjComponentesGenerados());            
                }
            }catch(java.lang.NullPointerException ex){}
	}
        
        /**
	 * Crear una Estructura en Árbol de un <code>ComponenteDistribuidorGeneradorMetodoSetter</code>.
         * @param objRaizParent 
         * @param objComponenteGeneradorMetodo Componente por el cual se Generará la Estructura.
	 */
        public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorMetodoSetter objComponenteGeneradorMetodo) {	

            ComponenteDistribuidorGenerador objComponenteGeneradorParametro = objComponenteGeneradorMetodo.getObjComponenteGeneradorParam();            
            if(objComponenteGeneradorParametro instanceof ComponenteDistribuidorGeneradorUnitario){
                GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorUnitario) objComponenteGeneradorParametro);
            }
            else if(objComponenteGeneradorParametro instanceof ComponenteDistribuidorGeneradorString){
                GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorString) objComponenteGeneradorParametro);
            }
            else if(objComponenteGeneradorParametro instanceof ComponenteDistribuidorGeneradorEnum){
                GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorEnum) objComponenteGeneradorParametro);
            }
            else if(objComponenteGeneradorParametro instanceof ComponenteDistribuidorGeneradorVinculador){
                GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorVinculador) objComponenteGeneradorParametro);
            }
            else if(objComponenteGeneradorParametro instanceof ComponenteDistribuidorGeneradorClaseCompleja){
                GeneradorArbol.crearEstructura(objRaizParent, (ComponenteDistribuidorGeneradorClaseCompleja) objComponenteGeneradorParametro);
            }
            if(!objComponenteGeneradorMetodo.getObjComponentesGenerados().isEmpty()){
                GeneradorArbol.crearEstructuraColeccionComponentesGenerados(objRaizParent, objComponenteGeneradorMetodo.getObjComponentesGenerados());            
            }            
	}
        
        /**
	 * @DefinicionMetodo
	 * @param objComponenteGenerador @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorUnitario objComponenteGenerador) {
            DefaultMutableTreeNode nodoComponentesGenerados = null;
            DefaultMutableTreeNode nodoComponenteGenerador = null;
            DefaultMutableTreeNode nodoClassPath = null;
            DefaultMutableTreeNode nodoClassPathComponente = null;
            DefaultMutableTreeNode nodoModeloAsociado = null;            
            DefaultMutableTreeNode nodoModeloIncluido = null;
            DefaultMutableTreeNode nodoComponenteModeloIncluido = null;
            DefaultMutableTreeNode nodoRaiz = null;
            DefaultMutableTreeNode nodoComponenteBeans = null;
            
            try{

                nodoRaiz =
                        crearNodoName(objComponenteGenerador);
                
                if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                    GeneradorArbol.crearEstructura(nodoRaiz, objComponenteGenerador);
                }
                else{

                    nodoClassPathComponente = 
                            crearNodoClassPath(objComponenteGenerador);

                    nodoRaiz.add(nodoClassPathComponente);

                    nodoClassPath =
                            crearNodoTipoDato(objComponenteGenerador.getObjTipoDato());
                    nodoRaiz.add(nodoClassPath);

                    nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                    nodoRaiz.add(nodoComponenteGenerador);

                    //Aqui se agregan los posibles componentes generados
                    nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteGenerador.getObjComponentesGenerados());
                    nodoRaiz.add(nodoComponentesGenerados);

                    if(objComponenteGenerador.isIntoCasoColeccion()){            
                        nodoModeloAsociado = crearEstructura(objComponenteGenerador.getObjModeloAsociado());                
                        //nodoModeloAsociado = crearEstructura(objComponenteGenerador.getObjModeloAsociado().getObjComponenteDistribuidorModeloAsociado());                
                        nodoRaiz.add(nodoModeloAsociado);            
                    }

                    if(objComponenteGenerador.isIntoCasoArray()){
                        nodoModeloIncluido = crearNodo("Componente Incluido");                                
                        if(objComponenteGenerador.getObjComponenteGeneradorIntoCasoArray() instanceof ComponenteDistribuidorGenerador){
                            nodoComponenteModeloIncluido = crearEstructura((ComponenteDistribuidorGenerador) objComponenteGenerador.getObjComponenteGeneradorIntoCasoArray());
                            nodoModeloIncluido.add(nodoComponenteModeloIncluido);
                        }
                        nodoRaiz.add(nodoModeloIncluido);
                    }
                    
                    if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                    
                        ComponenteBeans objComponenteBeans = objComponenteGenerador.getObjComponenteBeans();
                        if(objComponenteBeans != null){
                            nodoComponenteBeans = crearEstructura(objComponenteBeans);
                            nodoRaiz.add(nodoComponenteBeans);
                        }
                    }
                }
                
            }catch(java.lang.Exception ex){
                nodoRaiz =
                        crearNodo("No ha Creado un Componente Generador");
            }

            return nodoRaiz;
	}
        
        /**
	 * @DefinicionMetodo
         * @param objRaizParent 
         * @param objComponenteGenerador @DefinicionParametro
@DefinicionReturn
	 */
	public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorUnitario objComponenteGenerador) {
            DefaultMutableTreeNode nodoComponenteGenerador = null;                       
            DefaultMutableTreeNode nodoComponenteBeans = null;                       
            DefaultMutableTreeNode nodoModeloAsociado = null;
            DefaultMutableTreeNode nodoModeloIncluido = null;
            DefaultMutableTreeNode nodoComponenteModeloIncluido = null;
            try{                

                nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                objRaizParent.add(nodoComponenteGenerador);
                
                if(!objComponenteGenerador.getObjComponentesGenerados().isEmpty()){
                    GeneradorArbol.crearEstructuraColeccionComponentesGenerados(objRaizParent, objComponenteGenerador.getObjComponentesGenerados());
                }
                
                if(objComponenteGenerador.isIntoCasoColeccion()){            
                    nodoModeloAsociado = crearEstructura(objComponenteGenerador.getObjModeloAsociado());                                    
                    objRaizParent.add(nodoModeloAsociado);            
                }

                if(objComponenteGenerador.isIntoCasoArray()){
                    nodoModeloIncluido = crearNodo("Componente Incluido");                                
                    if(objComponenteGenerador.getObjComponenteGeneradorIntoCasoArray() instanceof ComponenteDistribuidorGenerador){
                        nodoComponenteModeloIncluido = crearEstructura((ComponenteDistribuidorGenerador) objComponenteGenerador.getObjComponenteGeneradorIntoCasoArray());
                        nodoModeloIncluido.add(nodoComponenteModeloIncluido);
                    }
                    objRaizParent.add(nodoModeloIncluido);
                }
                
                if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                
                    ComponenteBeans objComponenteBeans = objComponenteGenerador.getObjComponenteBeans();
                    if(objComponenteBeans != null){
                        nodoComponenteBeans = crearEstructura(objComponenteBeans);
                        objRaizParent.add(nodoComponenteBeans);
                    }
                }
                
            }catch(java.lang.Exception ex){
            }
	}
        
        /**
	 * @DefinicionMetodo
	 * @param objComponenteGenerador @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorString objComponenteGenerador) {
            DefaultMutableTreeNode nodoComponentesGenerados = null;
            DefaultMutableTreeNode nodoComponenteGenerador = null;
            DefaultMutableTreeNode nodoClassPath = null;
            DefaultMutableTreeNode nodoClassPathComponente = null;
            DefaultMutableTreeNode nodoRaiz = null;
            DefaultMutableTreeNode nodoComponenteBeans = null;
            
            try{

                nodoRaiz =
                        crearNodoName(objComponenteGenerador);
                
                if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                    GeneradorArbol.crearEstructura(nodoRaiz, objComponenteGenerador);
                }
                else{

                    nodoClassPathComponente = 
                            crearNodoClassPath(objComponenteGenerador);

                    nodoRaiz.add(nodoClassPathComponente);

                    nodoClassPath =
                            crearNodoTipoDato(objComponenteGenerador.getObjTipoDato());
                    nodoRaiz.add(nodoClassPath);

                    nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                    nodoRaiz.add(nodoComponenteGenerador);

                    //Aqui se agregan los posibles componentes generados
                    nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteGenerador.getObjComponentesGenerados());
                    nodoRaiz.add(nodoComponentesGenerados);
                    
                    if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                    
                        ComponenteBeans objComponenteBeans = objComponenteGenerador.getObjComponenteBeans();
                        if(objComponenteBeans != null){
                            nodoComponenteBeans = crearEstructura(objComponenteBeans);
                            nodoRaiz.add(nodoComponenteBeans);
                        }
                    }
                }
                
            }catch(java.lang.Exception ex){
                nodoRaiz =
                        crearNodo("No ha Creado un Componente Generador");
            }

            return nodoRaiz;
	}
        
        /**
	 * @DefinicionMetodo
         * @param objRaizParent 
         * @param objComponenteGenerador @DefinicionParametro
@DefinicionReturn
	 */
	public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorString objComponenteGenerador) {
            DefaultMutableTreeNode nodoComponenteGenerador = null;                       
            DefaultMutableTreeNode nodoComponenteBeans = null;                       
            
            try{                

                nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                objRaizParent.add(nodoComponenteGenerador);
                
                if(!objComponenteGenerador.getObjComponentesGenerados().isEmpty()){
                    GeneradorArbol.crearEstructuraColeccionComponentesGenerados(objRaizParent, objComponenteGenerador.getObjComponentesGenerados());
                }                
                
                if(objComponenteGenerador.getObjReflexionMetodosGetters() != null){
                    if(!objComponenteGenerador.getObjReflexionMetodosGetters().isEmpty()){
                        DefaultMutableTreeNode nodoPropiedades = crearNodo("Propiedades");        
                        GeneradorArbol.crearEstructura(nodoPropiedades, objComponenteGenerador.getObjReflexionMetodosGetters());
                        if(nodoPropiedades != null){
                            objRaizParent.add(nodoPropiedades);
                        }
                    }
                }
                
                if(!UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_AUTOGENERACION_BEANS_CDG)){        
                
                    ComponenteBeans objComponenteBeans = objComponenteGenerador.getObjComponenteBeans();
                    if(objComponenteBeans != null){
                        nodoComponenteBeans = crearEstructura(objComponenteBeans);
                        objRaizParent.add(nodoComponenteBeans);
                    }
                }
                
            }catch(java.lang.Exception ex){
            }
	}
        
        /**
	 * @DefinicionMetodo
         * @param objRaizParent 
         * @param objComponenteGenerador @DefinicionParametro
@DefinicionReturn
	 */
	public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorEnum objComponenteGenerador) {
            DefaultMutableTreeNode nodoComponenteGenerador = null;                       
            try{                

                nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                objRaizParent.add(nodoComponenteGenerador);
                GeneradorArbol.crearEstructuraColeccionComponentesGenerados(objRaizParent, objComponenteGenerador.getObjComponentesGenerados());
                
            }catch(java.lang.Exception ex){
            }
	}
        
        /**
	 * @DefinicionMetodo
         * @param objRaizParent 
         * @param objComponenteGenerador @DefinicionParametro
@DefinicionReturn
	 */
	public static void crearEstructura(DefaultMutableTreeNode objRaizParent, ComponenteDistribuidorGeneradorVinculador objComponenteGenerador) {
            DefaultMutableTreeNode nodoComponenteGenerador = null;                       
            try{                

                nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                objRaizParent.add(nodoComponenteGenerador);
                GeneradorArbol.crearEstructuraColeccionComponentesGenerados(objRaizParent, objComponenteGenerador.getObjComponentesGenerados());
                
            }catch(java.lang.Exception ex){
            }
	}
        
        
        /**
	 * 
	 * @param objComponenteGenerador
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorEnum objComponenteGenerador) {
           try{
                DefaultMutableTreeNode nodoComponentesGenerados = null;
                DefaultMutableTreeNode nodoComponenteGenerador = null;
                DefaultMutableTreeNode nodoClassPath = null;
                DefaultMutableTreeNode nodoClassPathComponente = null;            
                DefaultMutableTreeNode nodoEnumConstante = null;

                DefaultMutableTreeNode nodoRaiz = 
                        crearNodoName(objComponenteGenerador);

                nodoClassPathComponente = 
                        crearNodoClassPath(objComponenteGenerador);            
                nodoRaiz.add(nodoClassPathComponente);

                nodoClassPath =
                        crearNodoTipoDato(objComponenteGenerador.getObjTipoDato());

                for(String strEnum : objComponenteGenerador.getObjItems()){
                    nodoEnumConstante = 
                            crearNodo(
                                strEnum,
                                strEnum
                            );
                    nodoClassPath.add(nodoEnumConstante);
                }

                nodoRaiz.add(nodoClassPath);

                nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                nodoRaiz.add(nodoComponenteGenerador);

                //Aqui se agregan los posibles componentes generados
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteGenerador.getObjComponentesGenerados());
                nodoRaiz.add(nodoComponentesGenerados);

                return nodoRaiz;
	}catch(java.lang.NullPointerException ex){return null;}
           
        }
        
        /**
	 * 
	 * @param objComponenteGenerador
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorGeneradorVinculador objComponenteGenerador) {
          try{
                DefaultMutableTreeNode nodoComponentesGenerados = null;
                DefaultMutableTreeNode nodoComponenteGenerador = null;
                DefaultMutableTreeNode nodoClassPath = null;
                DefaultMutableTreeNode nodoClassPathComponente = null;            
                DefaultMutableTreeNode nodoEnumConstante = null;

                DefaultMutableTreeNode nodoRaiz = 
                        crearNodoName(objComponenteGenerador);

                nodoClassPathComponente = 
                        crearNodoClassPath(objComponenteGenerador);            
                nodoRaiz.add(nodoClassPathComponente);

                nodoClassPath =
                        crearNodoTipoDato(objComponenteGenerador.getObjTipoDato());

                for(String strEnum : objComponenteGenerador.getObjItems()){
                    nodoEnumConstante = 
                            crearNodo(
                                strEnum,
                                strEnum
                            );
                    nodoClassPath.add(nodoEnumConstante);
                }

                nodoRaiz.add(nodoClassPath);

                nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteGenerador.getObjComponenteGenerador());
                nodoRaiz.add(nodoComponenteGenerador);

                //Aqui se agregan los posibles componentes generados
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteGenerador.getObjComponentesGenerados());
                nodoRaiz.add(nodoComponentesGenerados);

                return nodoRaiz;
            }catch(java.lang.NullPointerException ex){return null;}
        }

	/**
	 * @DefinicionMetodo
	 * @param objComponenteExtra @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorExtra objComponenteExtra) {
            DefaultMutableTreeNode nodoComponenteGenerador = null;
            DefaultMutableTreeNode nodoComponentesGenerados = null;
            DefaultMutableTreeNode nodoClassPathComponente = null;
            DefaultMutableTreeNode nodoModeloAsociado = null;  
            DefaultMutableTreeNode nodoComponenteBeans = null;
            DefaultMutableTreeNode nodoRaiz = null;
            
            try{

                nodoRaiz =
                        crearNodoName(objComponenteExtra);

                nodoClassPathComponente = 
                        crearNodoClassPath(objComponenteExtra);
                nodoRaiz.add(nodoClassPathComponente);

                nodoComponenteGenerador = crearEstructura((ComponenteGeneradoInterno) objComponenteExtra.getObjComponenteGenerador());
                nodoRaiz.add(nodoComponenteGenerador);

                //Aqui se agregan los posibles componentes generados
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteExtra.getObjComponentesGenerados());
                nodoRaiz.add(nodoComponentesGenerados);

                if(objComponenteExtra.isIntoCasoColeccion()){
                    nodoModeloAsociado = crearEstructura(objComponenteExtra.getObjModeloAsociado());                
                    nodoRaiz.add(nodoModeloAsociado);
                }
                
                ComponenteBeans objComponenteBeans = objComponenteExtra.getObjComponenteBeans();
                if(objComponenteBeans != null){
                    nodoComponenteBeans = crearEstructura(objComponenteBeans);
                    nodoRaiz.add(nodoComponenteBeans);
                }
                
            }catch(java.lang.Exception ex){
                nodoRaiz =
                        crearNodo("No ha Creado un Componente Extra");
            }

            return nodoRaiz;
	}
        
        /**
         * 
         * @param objModeloAsociado
         * @return
         */
        public static DefaultMutableTreeNode crearEstructura(ModeloAsociado objModeloAsociado) {
            DefaultMutableTreeNode nodoModeloAsociado = null;
            DefaultMutableTreeNode nodoComponenteDistribuidor = null;
            
            try{                

                nodoModeloAsociado = crearNodo(objModeloAsociado.getStrName(), "Modelo Asociado", objModeloAsociado, GeneradorArbol.FORMAT_LABEL_B);                      

                ComponenteDistribuidor objComponenteModeloAsociado = objModeloAsociado.getObjComponenteDistribuidorModeloAsociado();
                nodoComponenteDistribuidor = crearEstructura((ComponenteDistribuidor) objComponenteModeloAsociado);
                nodoModeloAsociado.add(nodoComponenteDistribuidor);
                
            }catch(java.lang.Exception ex){
                nodoModeloAsociado = crearNodo("No ha Creado un Modelo Asociado");
            }
            
            return nodoModeloAsociado;
        }

	/**
	 * @DefinicionMetodo
	 * @param objComponenteContenedor @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorContenedorLibre objComponenteContenedor) {
           try{
                DefaultMutableTreeNode nodoComponenteExtra = null;
                DefaultMutableTreeNode nodoComponentesGenerados = null;

                DefaultMutableTreeNode nodoRaiz =
                        crearNodoName(objComponenteContenedor);

                //Se crea el bucle para extraer todos los componentes agregados (generadores, extras)
                for (Componente objComponente : objComponenteContenedor.getObjComponentes()) {
                    if (objComponente instanceof ComponenteDistribuidorIntegradorExtra) {
                        ComponenteDistribuidorIntegradorExtra objComponenteIntegradorExtra = (ComponenteDistribuidorIntegradorExtra) objComponente;
                        nodoComponenteExtra = crearEstructura(objComponenteIntegradorExtra);
                        nodoRaiz.add(nodoComponenteExtra);
                    }
                    else if (objComponente instanceof ComponenteDistribuidorExtra) {
                        ComponenteDistribuidorExtra objComponenteExtra = (ComponenteDistribuidorExtra) objComponente;
                        nodoComponenteExtra = crearEstructura(objComponenteExtra);
                        nodoRaiz.add(nodoComponenteExtra);
                    }
                }

                //Se insertan los Posibles Componentes Generados
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteContenedor.getObjComponentesGenerados());
                nodoRaiz.add(nodoComponentesGenerados);
                return nodoRaiz;
            }catch(java.lang.NullPointerException ex){return null;}
      }
        
        /**
	 * @DefinicionMetodo
	 * @param objComponenteDistribuidorModeloAsociado @DefinicionParametro
	 * @return @DefinicionReturn
	 */
    public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorModeloAsociado objComponenteDistribuidorModeloAsociado) {
      try{
            DefaultMutableTreeNode nodoComponenteDistribuidor = null;
            DefaultMutableTreeNode nodoComponentesGenerados = null;
            DefaultMutableTreeNode nodoComponentesBeans = null;

            DefaultMutableTreeNode nodoRaiz =
                    crearNodoName(objComponenteDistribuidorModeloAsociado);

            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){

                crearEstructura(nodoRaiz, objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorObject());            

                if(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey() != null){
                    crearEstructura(nodoRaiz, objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey());                
                }            

                //Se insertan los Posibles Componentes Generados
                if(!objComponenteDistribuidorModeloAsociado.getObjComponentesGenerados().isEmpty()){
                    crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteDistribuidorModeloAsociado.getObjComponentesGenerados());
                }            
            }
            else{

                nodoComponenteDistribuidor = crearEstructura(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorObject());
                nodoRaiz.add(nodoComponenteDistribuidor);

                if(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey() != null){
                    nodoComponenteDistribuidor = crearEstructura(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey());
                    nodoRaiz.add(nodoComponenteDistribuidor);                
                }            

                //Se insertan los Posibles Componentes Generados
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteDistribuidorModeloAsociado.getObjComponentesGenerados());
                nodoRaiz.add(nodoComponentesGenerados);

                nodoComponentesBeans = crearEstructura(objComponenteDistribuidorModeloAsociado.getObjComponenteBeans());
                nodoRaiz.add(nodoComponentesBeans);            
            }          
            return nodoRaiz;
        }catch(java.lang.NullPointerException ex){return null;}
    }        
    
    /**
     * 
     * @param objNodoRaizParent
     * @param objComponenteDistribuidorModeloAsociado
     */
    public static void crearEstructura(DefaultMutableTreeNode objNodoRaizParent, ComponenteDistribuidorModeloAsociado objComponenteDistribuidorModeloAsociado) {
     try{
            DefaultMutableTreeNode nodoComponenteDistribuidor = null;
            DefaultMutableTreeNode nodoComponentesGenerados = null;
            DefaultMutableTreeNode nodoComponentesBeans = null;

            DefaultMutableTreeNode nodoRaiz =
                    crearNodoName(objComponenteDistribuidorModeloAsociado);

            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){

                crearEstructura(nodoRaiz, objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorObject());            

                if(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey() != null){
                    crearEstructura(nodoRaiz, objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey());                
                }            

                //Se insertan los Posibles Componentes Generados
                if(!objComponenteDistribuidorModeloAsociado.getObjComponentesGenerados().isEmpty()){
                    crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteDistribuidorModeloAsociado.getObjComponentesGenerados());
                }            
            }
            else{

                nodoComponenteDistribuidor = crearEstructura(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorObject());
                nodoRaiz.add(nodoComponenteDistribuidor);

                if(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey() != null){
                    nodoComponenteDistribuidor = crearEstructura(objComponenteDistribuidorModeloAsociado.getObjComponenteDistribuidorKey());
                    nodoRaiz.add(nodoComponenteDistribuidor);                
                }            

                //Se insertan los Posibles Componentes Generados
                nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteDistribuidorModeloAsociado.getObjComponentesGenerados());
                nodoRaiz.add(nodoComponentesGenerados);

                nodoComponentesBeans = crearEstructura(objComponenteDistribuidorModeloAsociado.getObjComponenteBeans());
                nodoRaiz.add(nodoComponentesBeans);            
            }          
            objNodoRaizParent.add(nodoRaiz);
        }catch(java.lang.NullPointerException ex){}
   }    

	/**
	 * @DefinicionMetodo
	 * @param objComponenteContenedor @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructura(ComponenteDistribuidorContenedorEspejo objComponenteContenedor) {
            try{
                DefaultMutableTreeNode nodoComponenteDistribuidor = null;
                DefaultMutableTreeNode nodoComponentesGenerados = null;

                DefaultMutableTreeNode nodoRaiz =
                        crearNodoName(objComponenteContenedor);

                if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){

                    //Se crea el bucle para extraer todos los componentes agregados (generadores, extras)
                    for (Componente objComponente : objComponenteContenedor.getObjComponentes()) {
                        if (objComponente instanceof ComponenteDistribuidorIntegradorMetodo) {
                            ComponenteDistribuidorIntegradorMetodo objComponenteIntegradorMetodo = (ComponenteDistribuidorIntegradorMetodo) objComponente;
                            nodoComponenteDistribuidor = crearEstructura(objComponenteIntegradorMetodo);
                            nodoRaiz.add(nodoComponenteDistribuidor);
                        }
                        else if (objComponente instanceof ComponenteDistribuidorIntegradorSimple) {
                            ComponenteDistribuidorIntegradorSimple objComponenteIntegradorSimple = (ComponenteDistribuidorIntegradorSimple) objComponente;
                            nodoComponenteDistribuidor = crearEstructura(objComponenteIntegradorSimple);
                            nodoRaiz.add(nodoComponenteDistribuidor);
                        }                    
                    }

                    if(!objComponenteContenedor.getObjComponentesGenerados().isEmpty()){
                        GeneradorArbol.crearEstructuraColeccionComponentesGenerados(nodoRaiz, objComponenteContenedor.getObjComponentesGenerados());
                    }

                }
                else{

                    //Se crea el bucle para extraer todos los componentes agregados (generadores, extras)
                    for (Componente objComponente : objComponenteContenedor.getObjComponentes()) {
                        if (objComponente instanceof ComponenteDistribuidorIntegradorMetodo) {
                            ComponenteDistribuidorIntegradorMetodo objComponenteIntegradorMetodo = (ComponenteDistribuidorIntegradorMetodo) objComponente;
                            nodoComponenteDistribuidor = crearEstructura(objComponenteIntegradorMetodo);
                            nodoRaiz.add(nodoComponenteDistribuidor);
                        }
                        else if (objComponente instanceof ComponenteDistribuidorIntegradorSimple) {
                            ComponenteDistribuidorIntegradorSimple objComponenteIntegradorSimple = (ComponenteDistribuidorIntegradorSimple) objComponente;
                            nodoComponenteDistribuidor = crearEstructura(objComponenteIntegradorSimple);
                            nodoRaiz.add(nodoComponenteDistribuidor);
                        }                    
                    }

                    //Se insertan los Posibles Componentes Generados
                    nodoComponentesGenerados = crearEstructuraColeccionComponentesGenerados(objComponenteContenedor.getObjComponentesGenerados());
                    nodoRaiz.add(nodoComponentesGenerados);
                }
                return nodoRaiz;
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Contenedores Generados por el Asistente Espejo.");
            }
            return null;
        }

	/**
	 * @DefinicionMetodo
	 * @param objComponentesContenedores @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesContenedoresAsistenteLibre(ArrayList<ComponenteDistribuidorContenedor> objComponentesContenedores) {
            try{
                DefaultMutableTreeNode nodoComponentesDistribuidores = null;
                DefaultMutableTreeNode nodoComponenteDistribuidor = null;

                nodoComponentesDistribuidores = crearNodo("Componentes");

                for (ComponenteDistribuidorContenedor objComponenteContenedor : objComponentesContenedores) {
                    if (objComponenteContenedor instanceof ComponenteDistribuidorContenedorLibre) {
                        ComponenteDistribuidorContenedorLibre objComponenteContenedorAsistenteLibre =
                                (ComponenteDistribuidorContenedorLibre) objComponenteContenedor;
                        nodoComponenteDistribuidor = crearEstructura(objComponenteContenedorAsistenteLibre);
                        nodoComponentesDistribuidores.add(nodoComponenteDistribuidor);
                    }
                }
                return nodoComponentesDistribuidores;
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Contenedores Generados por el Asistente Libre.");
            }
            return null;
	}
        
        /**
         * 
         * @param objComponentesIntegradorMetodo
         * @return
         */
        public static DefaultMutableTreeNode crearEstructuraColeccionComponenteIntegradorMetodo(ArrayList<ComponenteDistribuidorIntegradorMetodo> objComponentesIntegradorMetodo) {
          try{
                DefaultMutableTreeNode nodoComponentesIntegradores = null;
                DefaultMutableTreeNode nodoComponenteIntegrador = null;

                nodoComponentesIntegradores = crearNodo("Componentes Integradores");

                for (ComponenteDistribuidorIntegradorMetodo objComponenteIntegradorMetodo : objComponentesIntegradorMetodo) {                
                    
                    nodoComponenteIntegrador = crearEstructura(objComponenteIntegradorMetodo);
                    nodoComponentesIntegradores.add(nodoComponenteIntegrador);                
                }
                return nodoComponentesIntegradores;
            }catch(java.lang.NullPointerException ex){
                return null;
            }
        }
        
        /**
         * 
         * @param objComponentesIntegradorSimple
         * @return
         */
        public static DefaultMutableTreeNode crearEstructuraColeccionComponenteIntegradorSimple(ArrayList<ComponenteDistribuidorIntegradorSimple> objComponentesIntegradorSimple) {
          try{
                DefaultMutableTreeNode nodoComponentesIntegradores = null;
                DefaultMutableTreeNode nodoComponenteIntegrador = null;

                nodoComponentesIntegradores = crearNodo("Componentes Integradores");

                for (ComponenteDistribuidorIntegradorSimple objComponenteIntegradorSimple : objComponentesIntegradorSimple) {                
                    
                    nodoComponenteIntegrador = crearEstructura(objComponenteIntegradorSimple);
                    nodoComponentesIntegradores.add(nodoComponenteIntegrador);                
                }
                return nodoComponentesIntegradores;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
         * 
         * @param objComponentesIntegradorExtra
         * @return
         */
        public static DefaultMutableTreeNode crearEstructuraColeccionComponenteIntegradorExtra(ArrayList<ComponenteDistribuidorIntegradorExtra> objComponentesIntegradorExtra) {
           try{
                DefaultMutableTreeNode nodoComponentesIntegradores = null;
                DefaultMutableTreeNode nodoComponenteIntegrador = null;

                nodoComponentesIntegradores = crearNodo("Componentes Integradores");

                for (ComponenteDistribuidorIntegradorExtra objComponenteIntegradorExtra : objComponentesIntegradorExtra) {                
                    
                    nodoComponenteIntegrador = crearEstructura(objComponenteIntegradorExtra);
                    nodoComponentesIntegradores.add(nodoComponenteIntegrador);                
                }
                return nodoComponentesIntegradores;
            }catch(java.lang.NullPointerException ex){return null;}
        }

	/**
	 * @DefinicionMetodo
	 * @param objComponentesContenedores @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesContenedoresAsistenteEspejo(ArrayList<ComponenteDistribuidorContenedor> objComponentesContenedores) {
          try{
                DefaultMutableTreeNode nodoComponentesContenedores = null;
                DefaultMutableTreeNode nodoComponenteContenedor = null;

                nodoComponentesContenedores = crearNodo("Componentes Contenedores");

                for (ComponenteDistribuidorContenedor objComponenteDitribuidorContenedor : objComponentesContenedores) {
                    if (objComponenteDitribuidorContenedor instanceof ComponenteDistribuidorContenedorEspejo) {
                        ComponenteDistribuidorContenedorEspejo objComponenteContenedorAsistenteEspejo =
                                (ComponenteDistribuidorContenedorEspejo) objComponenteDitribuidorContenedor;
                        nodoComponenteContenedor = crearEstructura(objComponenteContenedorAsistenteEspejo);
                        nodoComponentesContenedores.add(nodoComponenteContenedor);
                    }
                }

                return nodoComponentesContenedores;
            }catch(java.lang.NullPointerException ex){return null;}
        }

	/**
	 * @DefinicionMetodo
	 * @param objComponentesDistribuidoresContenedores @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesContenedores(ArrayList<ComponenteDistribuidorContenedor> objComponentesDistribuidoresContenedores) {
           try{
                DefaultMutableTreeNode nodoComponentesDistribuidoresContenedores = null;
                DefaultMutableTreeNode nodoComponenteDistribuidorContenedor = null;
                nodoComponentesDistribuidoresContenedores = crearNodo("Formularios");
                for (ComponenteDistribuidorContenedor objComponenteDistribuidorContenedor : objComponentesDistribuidoresContenedores) {
                    if (objComponenteDistribuidorContenedor instanceof ComponenteDistribuidorContenedorLibre) {
                        ComponenteDistribuidorContenedorLibre objComponenteContenedorAsistenteLibre =
                                (ComponenteDistribuidorContenedorLibre) objComponenteDistribuidorContenedor;
                        nodoComponenteDistribuidorContenedor = crearEstructura(objComponenteContenedorAsistenteLibre);
                        nodoComponentesDistribuidoresContenedores.add(nodoComponenteDistribuidorContenedor);
                    } 
                    else if (objComponenteDistribuidorContenedor instanceof ComponenteDistribuidorContenedorEspejo) {
                        ComponenteDistribuidorContenedorEspejo objComponenteContenedorAsistenteEspejo =
                                (ComponenteDistribuidorContenedorEspejo) objComponenteDistribuidorContenedor;
                        nodoComponenteDistribuidorContenedor = crearEstructura(objComponenteContenedorAsistenteEspejo);
                        nodoComponentesDistribuidoresContenedores.add(nodoComponenteDistribuidorContenedor);
                    }
                }
                return nodoComponentesDistribuidoresContenedores;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        /**
	 * @DefinicionMetodo
	 * @param objComponentesDistribuidoresIntegradores @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesIntegradores(ArrayList<ComponenteDistribuidorIntegrador> objComponentesDistribuidoresIntegradores) {
          try{
                DefaultMutableTreeNode nodoComponentesDistribuidoresIntegradores = null;
                DefaultMutableTreeNode nodoComponenteDistribuidorIntegrador = null;

                nodoComponentesDistribuidoresIntegradores = crearNodo("Paneles");

                for (ComponenteDistribuidorIntegrador objComponenteDistribuidorIntegrador : objComponentesDistribuidoresIntegradores) {
                    if (objComponenteDistribuidorIntegrador instanceof ComponenteDistribuidorIntegradorExtra) {
                        ComponenteDistribuidorIntegradorExtra objComponenteIntegradorExtra =
                                (ComponenteDistribuidorIntegradorExtra) objComponenteDistribuidorIntegrador;
                        nodoComponenteDistribuidorIntegrador = crearEstructura(objComponenteIntegradorExtra);
                        nodoComponentesDistribuidoresIntegradores.add(nodoComponenteDistribuidorIntegrador);
                    } 
                    else if (objComponenteDistribuidorIntegrador instanceof ComponenteDistribuidorIntegradorMetodo) {
                        ComponenteDistribuidorIntegradorMetodo objComponenteIntegradorMetodo =
                                (ComponenteDistribuidorIntegradorMetodo) objComponenteDistribuidorIntegrador;
                        nodoComponenteDistribuidorIntegrador = crearEstructura(objComponenteIntegradorMetodo);
                        nodoComponentesDistribuidoresIntegradores.add(nodoComponenteDistribuidorIntegrador);
                    }
                    else if (objComponenteDistribuidorIntegrador instanceof ComponenteDistribuidorIntegradorSimple) {
                        ComponenteDistribuidorIntegradorSimple objComponenteIntegradorSimple =
                                (ComponenteDistribuidorIntegradorSimple) objComponenteDistribuidorIntegrador;
                        nodoComponenteDistribuidorIntegrador = crearEstructura(objComponenteIntegradorSimple);
                        nodoComponentesDistribuidoresIntegradores.add(nodoComponenteDistribuidorIntegrador);
                    }
                }

                return nodoComponentesDistribuidoresIntegradores;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
         * 
         * @param objComponentesDistribuidoresIntegradores
         * @return
         */
        public static DefaultMutableTreeNode crearEstructuraColeccionComponentesIntegradoresExtras(ArrayList<ComponenteDistribuidorIntegrador> objComponentesDistribuidoresIntegradores) {
          try{
                DefaultMutableTreeNode nodoComponentesDistribuidoresIntegradores = null;
                DefaultMutableTreeNode nodoComponenteDistribuidorIntegrador = null;

                nodoComponentesDistribuidoresIntegradores = crearNodo("Componentes Integradores");

                for (ComponenteDistribuidorIntegrador objComponenteDistribuidorIntegrador : objComponentesDistribuidoresIntegradores) {
                    if (objComponenteDistribuidorIntegrador instanceof ComponenteDistribuidorIntegradorExtra) {
                        ComponenteDistribuidorIntegradorExtra objComponenteIntegradorExtra =
                                (ComponenteDistribuidorIntegradorExtra) objComponenteDistribuidorIntegrador;
                        nodoComponenteDistribuidorIntegrador = crearEstructura(objComponenteIntegradorExtra);
                        nodoComponentesDistribuidoresIntegradores.add(nodoComponenteDistribuidorIntegrador);
                    }
                }

                return nodoComponentesDistribuidoresIntegradores;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
         * 
         * @param objComponentesDistribuidoresIntegradores
         * @return
         */
        public static DefaultMutableTreeNode crearEstructuraColeccionComponentesIntegradoresGeneradores(ArrayList<ComponenteDistribuidorIntegrador> objComponentesDistribuidoresIntegradores) {
            try{
                DefaultMutableTreeNode nodoComponentesDistribuidoresIntegradores = null;            
                DefaultMutableTreeNode nodoComponenteDistribuidorIntegrador = null;

                nodoComponentesDistribuidoresIntegradores = crearNodo("Componentes Integradores");

                for (ComponenteDistribuidorIntegrador objComponenteDistribuidorIntegrador : objComponentesDistribuidoresIntegradores) {
                    if (objComponenteDistribuidorIntegrador instanceof ComponenteDistribuidorIntegradorMetodo) {
                        ComponenteDistribuidorIntegradorMetodo objComponenteIntegradorMetodo =
                                (ComponenteDistribuidorIntegradorMetodo) objComponenteDistribuidorIntegrador;
                        nodoComponenteDistribuidorIntegrador = crearEstructura(objComponenteIntegradorMetodo);
                        nodoComponentesDistribuidoresIntegradores.add(nodoComponenteDistribuidorIntegrador);
                    }
                    else if (objComponenteDistribuidorIntegrador instanceof ComponenteDistribuidorIntegradorSimple) {
                        ComponenteDistribuidorIntegradorSimple objComponenteIntegradorSimple =
                                (ComponenteDistribuidorIntegradorSimple) objComponenteDistribuidorIntegrador;
                        nodoComponenteDistribuidorIntegrador = crearEstructura(objComponenteIntegradorSimple);
                        nodoComponentesDistribuidoresIntegradores.add(nodoComponenteDistribuidorIntegrador);
                    }
                }
                return nodoComponentesDistribuidoresIntegradores;
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Componentes Integradores Generadores.");
            }
            return null;
	}

	/**
	 * @DefinicionMetodo
         * @param objComponentesGeneradores  @param auto 
         * @DefinicionParametro
         * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesGeneradoresModeAuto(ArrayList<ComponenteDistribuidorGenerador> objComponentesGeneradores, boolean auto) {
          try{
                DefaultMutableTreeNode nodoComponentesGeneradores = null;
                DefaultMutableTreeNode nodoComponenteGenerador = null;

                nodoComponentesGeneradores = crearNodo("Componentes Generadores");

                for (ComponenteDistribuidorGenerador objComponenteGenerador : objComponentesGeneradores) {
                    if(objComponenteGenerador.isAuto() == auto){
                        if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorEnum) {
                            ComponenteDistribuidorGeneradorEnum objComponenteGeneradorEnum =
                                    (ComponenteDistribuidorGeneradorEnum) objComponenteGenerador;                    
                            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                                nodoComponenteGenerador = crearNodoName(objComponenteGeneradorEnum);
                                GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorEnum);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                            else{
                                nodoComponenteGenerador = crearEstructura(objComponenteGeneradorEnum);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                        } 
                        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorVinculador) {
                            ComponenteDistribuidorGeneradorVinculador objComponenteGeneradorVinculador =
                                    (ComponenteDistribuidorGeneradorVinculador) objComponenteGenerador;                    
                            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                                nodoComponenteGenerador = crearNodoName(objComponenteGeneradorVinculador);
                                GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorVinculador);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                            else{
                                nodoComponenteGenerador = crearEstructura(objComponenteGeneradorVinculador);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                        }
                        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorUnitario) {
                            ComponenteDistribuidorGeneradorUnitario objComponenteGeneradorUnitario =
                                    (ComponenteDistribuidorGeneradorUnitario) objComponenteGenerador;
                            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                                nodoComponenteGenerador = crearNodoName(objComponenteGenerador);
                                GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorUnitario);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                            else{
                                nodoComponenteGenerador = crearEstructura(objComponenteGeneradorUnitario);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                        }                        
                        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorString) {
                            ComponenteDistribuidorGeneradorString objComponenteGeneradorString =
                                    (ComponenteDistribuidorGeneradorString) objComponenteGenerador;
                            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                                nodoComponenteGenerador = crearNodoName(objComponenteGenerador);
                                GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorString);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                            else{
                                nodoComponenteGenerador = crearEstructura(objComponenteGeneradorString);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                        }
                        else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorClaseCompleja) {
                            ComponenteDistribuidorGeneradorClaseCompleja objComponenteGeneradorClase =
                                    (ComponenteDistribuidorGeneradorClaseCompleja) objComponenteGenerador;
                            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                                GeneradorArbol.crearEstructura(nodoComponentesGeneradores, objComponenteGeneradorClase);
                            }
                            else{
                                nodoComponenteGenerador = crearEstructura(objComponenteGeneradorClase);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }                    
                        }
                    }
                }            
                return nodoComponentesGeneradores;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
	 * @DefinicionMetodo
         * @param objComponentesGeneradores  @param modeInOut 
         * @DefinicionParametro
         * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesGeneradoresModeInOut(ArrayList<ComponenteDistribuidorGenerador> objComponentesGeneradores, boolean modeInOut) {
           try{
                DefaultMutableTreeNode nodoComponentesGeneradores = null;
                DefaultMutableTreeNode nodoComponenteGenerador = null;

                nodoComponentesGeneradores = crearNodo("Componentes Generadores");

                for (ComponenteDistribuidorGenerador objComponenteGenerador : objComponentesGeneradores) {
                    if(modeInOut){//Entrada - Incluyen Vinculadores
                        if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorVinculador) {
                            ComponenteDistribuidorGeneradorVinculador objComponenteGeneradorVinculador =
                                    (ComponenteDistribuidorGeneradorVinculador) objComponenteGenerador;                    
                            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                                nodoComponenteGenerador = crearNodoName(objComponenteGeneradorVinculador);
                                GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorVinculador);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                            else{
                                nodoComponenteGenerador = crearEstructura(objComponenteGeneradorVinculador);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                        }
                    }
                    else{//Salida - Incluye String
                        if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorString) {
                            ComponenteDistribuidorGeneradorString objComponenteGeneradorString =
                                    (ComponenteDistribuidorGeneradorString) objComponenteGenerador;
                            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                                nodoComponenteGenerador = crearNodoName(objComponenteGenerador);
                                GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorString);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                            else{
                                nodoComponenteGenerador = crearEstructura(objComponenteGeneradorString);
                                nodoComponentesGeneradores.add(nodoComponenteGenerador);
                            }
                        }                    
                    }                    
                    if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorEnum) {
                        ComponenteDistribuidorGeneradorEnum objComponenteGeneradorEnum =
                                (ComponenteDistribuidorGeneradorEnum) objComponenteGenerador;                    
                        if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                            nodoComponenteGenerador = crearNodoName(objComponenteGeneradorEnum);
                            GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorEnum);
                            nodoComponentesGeneradores.add(nodoComponenteGenerador);
                        }
                        else{
                            nodoComponenteGenerador = crearEstructura(objComponenteGeneradorEnum);
                            nodoComponentesGeneradores.add(nodoComponenteGenerador);
                        }
                    }                 
                    else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorUnitario) {
                        ComponenteDistribuidorGeneradorUnitario objComponenteGeneradorUnitario =
                                (ComponenteDistribuidorGeneradorUnitario) objComponenteGenerador;
                        if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                            nodoComponenteGenerador = crearNodoName(objComponenteGenerador);
                            GeneradorArbol.crearEstructura(nodoComponenteGenerador, objComponenteGeneradorUnitario);
                            nodoComponentesGeneradores.add(nodoComponenteGenerador);
                        }
                        else{
                            nodoComponenteGenerador = crearEstructura(objComponenteGeneradorUnitario);
                            nodoComponentesGeneradores.add(nodoComponenteGenerador);
                        }
                    }                                        
                    else if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorClaseCompleja) {
                        ComponenteDistribuidorGeneradorClaseCompleja objComponenteGeneradorClase =
                                (ComponenteDistribuidorGeneradorClaseCompleja) objComponenteGenerador;
                        if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                            GeneradorArbol.crearEstructura(nodoComponentesGeneradores, objComponenteGeneradorClase);
                        }
                        else{
                            nodoComponenteGenerador = crearEstructura(objComponenteGeneradorClase);
                            nodoComponentesGeneradores.add(nodoComponenteGenerador);
                        }                    
                    }
                }                        
                return nodoComponentesGeneradores;
            }catch(java.lang.NullPointerException ex){return null;}
        }
        
        /**
         * 
         * @param objComponentesGeneradoresClase
         * @return
         */
        public static DefaultMutableTreeNode crearEstructuraColeccionComponentesGeneradoresClase(ArrayList<ComponenteDistribuidorGeneradorClaseCompleja> objComponentesGeneradoresClase) {
            try{
                DefaultMutableTreeNode nodoComponentesGeneradores = null;
                DefaultMutableTreeNode nodoComponenteGenerador = null;

                nodoComponentesGeneradores = crearNodo("Paneles");

                for (ComponenteDistribuidorGenerador objComponenteGenerador : objComponentesGeneradoresClase) {
                    if (objComponenteGenerador instanceof ComponenteDistribuidorGeneradorClaseCompleja) {
                        ComponenteDistribuidorGeneradorClaseCompleja objComponenteGeneradorClase =
                                (ComponenteDistribuidorGeneradorClaseCompleja) objComponenteGenerador;
                        if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                            GeneradorArbol.crearEstructura(nodoComponentesGeneradores, objComponenteGeneradorClase);
                        }
                        else{
                            nodoComponenteGenerador = crearEstructura(objComponenteGeneradorClase);
                            nodoComponentesGeneradores.add(nodoComponenteGenerador);
                        }

                    }
                }
                return nodoComponentesGeneradores;
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Componentes Clase Mundo.");
            }
            return null;
        }
        
        /**
         * 
         * @param objComponentesModelosAsociados
         * @return
         */
        public static DefaultMutableTreeNode crearEstructuraColeccionComponentesModelosAsociados(ArrayList<ComponenteDistribuidorModeloAsociado> objComponentesModelosAsociados) {
            try{
                DefaultMutableTreeNode nodoComponentesModelosAsociados = null;
                DefaultMutableTreeNode nodoComponenteModeloAsociado = null;

                nodoComponentesModelosAsociados = crearNodo("Dialogos");

                for (ComponenteDistribuidorModeloAsociado objComponenteModeloAsociado : objComponentesModelosAsociados) {                
                    if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_VIEW_SIMPLE_TREVIEW)){
                        GeneradorArbol.crearEstructura(nodoComponentesModelosAsociados, objComponenteModeloAsociado);
                    }
                    else{
                        nodoComponenteModeloAsociado = crearEstructura(objComponenteModeloAsociado);
                        nodoComponentesModelosAsociados.add(nodoComponenteModeloAsociado);
                    }
                }
                return nodoComponentesModelosAsociados;
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Modelos Asociados..");
            }
            return null;
	}

	/**
	 * @DefinicionMetodo
         * @param objComponentesExtras  @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesExtras(ArrayList<ComponenteDistribuidorExtra> objComponentesExtras) {
            try{
                DefaultMutableTreeNode nodoComponentesExtras = null;
                DefaultMutableTreeNode nodoComponenteExtra = null;
                nodoComponentesExtras = crearNodo("Componentes Extras");
                for (ComponenteDistribuidorExtra objComponenteExtra : objComponentesExtras) {
                    
                    nodoComponenteExtra = crearEstructura(objComponenteExtra);
                    nodoComponentesExtras.add(nodoComponenteExtra);
                }
                return nodoComponentesExtras;
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Componentes Extras.");
            }
            return null;
	}

	/**
	 * @DefinicionMetodo
	 * @param objComponentesGenerados @DefinicionParametro
	 * @return @DefinicionReturn
	 */
	public static DefaultMutableTreeNode crearEstructuraColeccionComponentesGenerados(ArrayList<ComponenteGeneradoSimple> objComponentesGenerados) {
            try{
                DefaultMutableTreeNode nodoComponentesGenerados = null;      
                DefaultMutableTreeNode nodoComponenteGenerado = null;            

                nodoComponentesGenerados = crearNodo("Componentes Generados");

                for (ComponenteGeneradoSimple objComponenteGenerado : objComponentesGenerados) {
                    
                    nodoComponenteGenerado = crearEstructura(objComponenteGenerado);					
                    nodoComponentesGenerados.add(nodoComponenteGenerado);
                }
                return nodoComponentesGenerados;
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Componentes Generados.");
            }
            return null;
	}
        
        /**
	 * @DefinicionMetodo
         * @param objRaizParent 
         * @param objComponentesGenerados @DefinicionParametro
@DefinicionReturn
	 */
	public static void crearEstructuraColeccionComponentesGenerados(DefaultMutableTreeNode objRaizParent, ArrayList<ComponenteGeneradoSimple> objComponentesGenerados) {            
            try{
                DefaultMutableTreeNode nodoComponenteGenerado = null;            
                for (ComponenteGeneradoSimple objComponenteGenerado : objComponentesGenerados) {
                    
                    nodoComponenteGenerado = crearEstructura(objComponenteGenerado);					
                    objRaizParent.add(nodoComponenteGenerado);
                }
            }catch(java.lang.NullPointerException ex){
                System.out.println("Error en al Generación del Árbol de Modelos Asociados..");
            }
        }

	/**
	 * Devuelve el Arbol que representa el Vector.
	 * @param nodoRaiz @DefinicionParametro
	 * @param objComponentesGeneradores @DefinicionParametro
	 * @throws SecurityException @DefinicionExcepcion
	 */
	public static void crearEstructuraComponentes(DefaultMutableTreeNode nodoRaiz, ArrayList<ComponenteDistribuidorGenerador> objComponentesGeneradores) throws SecurityException {            
            try {
                for (ComponenteDistribuidorGenerador objComponenteGenerador : objComponentesGeneradores) {
                    
                    DefaultMutableTreeNode nodoComponenteGenerador = GeneradorArbol.crearEstructura(objComponenteGenerador);
                    nodoRaiz.add(nodoComponenteGenerador);
                }
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
	}

	/**
	 * Devuelve el Arbol que representa el Vector.
	 * @param strRaiz @DefinicionParametro
         * @param objBiblioteca @param auto 
         * @DefinicionParametro
	 * @return @DefinicionReturn
	 * @throws SecurityException @DefinicionExcepcion
	 */
	public static DefaultMutableTreeNode crearEstructuraBibliotecaAll(String strRaiz, BibliotecaTrabajo objBiblioteca, boolean auto) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoComponenteContenedor = null;
            DefaultMutableTreeNode nodoComponenteIntegrador = null;
            DefaultMutableTreeNode nodoComponenteGenerador = null;
            DefaultMutableTreeNode nodoComponenteExtra = null;
            DefaultMutableTreeNode nodoComponenteGenerado = null;

            try {
                if(!objBiblioteca.getObjComponentesContenedores().isEmpty()){
                    nodoComponenteContenedor = GeneradorArbol.crearEstructuraColeccionComponentesContenedores(objBiblioteca.getObjComponentesContenedores());
                    nodoRaiz.add(nodoComponenteContenedor);
                }
                if(!objBiblioteca.getObjComponentesIntegradores().isEmpty()){
                    nodoComponenteIntegrador = GeneradorArbol.crearEstructuraColeccionComponentesIntegradores(objBiblioteca.getObjComponentesIntegradores());
                    nodoRaiz.add(nodoComponenteIntegrador);
                }
                if(!objBiblioteca.getObjComponentesGeneradores().isEmpty()){
                    nodoComponenteGenerador = GeneradorArbol.crearEstructuraColeccionComponentesGeneradoresModeAuto(objBiblioteca.getObjComponentesGeneradores(), auto);
                    nodoRaiz.add(nodoComponenteGenerador);
                }
                if(!objBiblioteca.getObjComponentesExtras().isEmpty()){
                    nodoComponenteExtra = GeneradorArbol.crearEstructuraColeccionComponentesExtras(objBiblioteca.getObjComponentesExtras());
                    nodoRaiz.add(nodoComponenteExtra);
                }
                if(!objBiblioteca.getObjComponentesGenerados().isEmpty()){
                    nodoComponenteGenerado = GeneradorArbol.crearEstructuraColeccionComponentesGenerados(objBiblioteca.getObjComponentesGenerados());
                    nodoRaiz.add(nodoComponenteGenerado);
                }
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
        
        /**
         * 
         * @param strRaiz
         * @param objBiblioteca
         * @param auto
         * @return
         * @throws SecurityException
         */
        public static DefaultMutableTreeNode crearEstructuraBibliotecaPatron(String strRaiz, BibliotecaTrabajo objBiblioteca, boolean auto) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoComponenteGenerador = null;            
            try {                
                if(!objBiblioteca.getObjComponentesGeneradores().isEmpty()){
                    nodoComponenteGenerador = GeneradorArbol.crearEstructuraColeccionComponentesGeneradoresModeAuto(objBiblioteca.getObjComponentesGeneradores(), auto);
                    nodoRaiz.add(nodoComponenteGenerador);
                }                
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
        
        /**
         * 
         * @param strRaiz
         * @param objBiblioteca
         * @param tipoComponente
         * @return
         * @throws SecurityException
         */
        public static DefaultMutableTreeNode crearEstructuraBibliotecaPersonalizada(String strRaiz, BibliotecaTrabajo objBiblioteca, int[] tipoComponente) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoComponente = null;
            try {
                for(int i : tipoComponente){                    
                    switch(i){
                        case Componente.COMPONENTE_DISTRIBUIDOR_INTEGRADOR:
                            nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesIntegradores(objBiblioteca.getObjComponentesIntegradores());
                            nodoRaiz.add(nodoComponente);
                            break;
                            
                        case Componente.COMPONENTE_DISTRIBUIDOR_GENERADOR:
                            nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesGeneradoresModeAuto(objBiblioteca.getObjComponentesGeneradores(), false);
                            nodoRaiz.add(nodoComponente);
                            break;
                            
                        case Componente.COMPONENTE_DISTRIBUIDOR_EXTRA:
                            nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesExtras(objBiblioteca.getObjComponentesExtras());
                            nodoRaiz.add(nodoComponente);
                            break;
                    }                    
                }
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
        
        /**
         * 
         * @param strRaiz
         * @param objBiblioteca
         * @param tipoComponente
         * @param exclusion
         * @return
         * @throws SecurityException
         */
        public static DefaultMutableTreeNode crearEstructuraBibliotecaPersonalizada(String strRaiz, BibliotecaTrabajo objBiblioteca, int[] tipoComponente, int exclusion) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoComponente = null;
            try {
                for(int i : tipoComponente){                    
                    switch(i){
                        case Componente.COMPONENTE_DISTRIBUIDOR_INTEGRADOR:
                            
                            if(exclusion == BibliotecaTrabajo.EXCLUSION_CDIE){
                                nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesIntegradoresGeneradores(objBiblioteca.getObjComponentesIntegradores());
                            }
                            else if(exclusion == BibliotecaTrabajo.EXCLUSION_CDIG){
                                nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesIntegradoresExtras(objBiblioteca.getObjComponentesIntegradores());
                            }
                            else{//No Aplica Exclusion
                                nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesIntegradores(objBiblioteca.getObjComponentesIntegradores());
                            }
                            nodoRaiz.add(nodoComponente);
                            break;
                            
                        case Componente.COMPONENTE_DISTRIBUIDOR_GENERADOR:
                            nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesGeneradoresModeAuto(objBiblioteca.getObjComponentesGeneradores(), false);
                            nodoRaiz.add(nodoComponente);
                            break;
                            
                        case Componente.COMPONENTE_DISTRIBUIDOR_EXTRA:
                            nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesExtras(objBiblioteca.getObjComponentesExtras());
                            nodoRaiz.add(nodoComponente);
                            break;
                    }                    
                }
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
        
        /**
         * 
         * @param strRaiz
         * @param objBiblioteca
         * @param objTipoDato
         * @return
         * @throws SecurityException
         */
        public static DefaultMutableTreeNode crearEstructuraBibliotecaPersonalizadaPorTipoDato(String strRaiz, BibliotecaTrabajo objBiblioteca, ObjetoTipoDatoReflexion objTipoDato) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoComponente = null;
            try {
                nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesGeneradoresModeAuto(objBiblioteca.devolverColeccionRepresentacionesTipoDato(objTipoDato), false);
                nodoRaiz.add(nodoComponente);
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
        
        /**
         * 
         * @param strRaiz
         * @param objBiblioteca
         * @param objTipoDato
         * @param modeInOut 
         * @return
         * @throws SecurityException
         */
        public static DefaultMutableTreeNode crearEstructuraBibliotecaPersonalizadaPorTipoDato(String strRaiz, BibliotecaTrabajo objBiblioteca, ObjetoTipoDatoReflexion objTipoDato, boolean modeInOut) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoComponente = null;
            try {
                nodoComponente = GeneradorArbol.crearEstructuraColeccionComponentesGeneradoresModeInOut(objBiblioteca.devolverColeccionRepresentacionesTipoDato(objTipoDato), modeInOut);
                nodoRaiz.add(nodoComponente);
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}        
        
        /**
         * 
         * @param strRaiz
         * @param objBiblioteca
         * @return
         * @throws SecurityException
         */
        public static DefaultMutableTreeNode crearEstructuraBibliotecaModelsStatics(String strRaiz, BibliotecaTrabajo objBiblioteca) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoModelo = null;
            DefaultMutableTreeNode nodoItem = null;
            try {
                for(StaticListModelObject objModel : objBiblioteca.getObjStaticListModelString().values()){
                    nodoModelo = crearNodo(objModel.getName(), objModel);
                    for(ItemStaticListModelObject objItem : objModel.getObjItems()){
                        nodoItem = crearNodo(objItem.getName(), objItem);
                        nodoModelo.add(nodoItem);
                    }                    
                    nodoRaiz.add(nodoModelo);
                }                                
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}

	/**
	 * Devuelve el Arbol que representa el Vector.
         * @param strRaiz @DefinicionParametro
	 * @param objClases @DefinicionParametro
         * @return  @DefinicionReturn
         * @throws SecurityException @DefinicionExcepcion
	 */
	public static DefaultMutableTreeNode crearEstructuraClasesMundoJar(String strRaiz, ArrayList<ObjetoReflexion> objClases) throws SecurityException {            
            if(strRaiz != null && objClases != null){
                DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
                DefaultMutableTreeNode nodoClase = null;
                for (int i = 0; i < objClases.size(); i++) {
                    ObjetoReflexion obj = (ObjetoReflexion) objClases.get(i);
                    try{
                        if(!obj.isAbstractClass()){
                            Class objClase = obj.getObj().getClass();
                            nodoClase = crearEstructura(objClase);
                            nodoRaiz.add(nodoClase);
                        }
                    }catch(java.lang.Exception ex){
                        continue;
                    }
                }
                return nodoRaiz;                           
            }
            else {
                System.out.println("Raiz ó Colección Nula.");
            }
           return null;
	}
        
        /**
	 * Devuelve el Arbol que representa el Vector.
@DefinicionParametro
	 * @param objModeloAnalizado @DefinicionParametro
         * @return  @DefinicionReturn
         * @throws SecurityException @DefinicionExcepcion
	 */
	public static DefaultMutableTreeNode crearEstructura(ObjetoReflexion objModeloAnalizado) throws SecurityException {            
            try {
                if(objModeloAnalizado.getObj() instanceof Method){
                    return crearEstructura((Method) objModeloAnalizado.getObj());
                }
                else if(objModeloAnalizado.getObj() instanceof Field){
                    return crearEstructura((Field) objModeloAnalizado.getObj());
                }
                else if(objModeloAnalizado.getObjClass() != null){
                    return crearEstructura(objModeloAnalizado.getObjClass());
                }
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}

	/**
	 * Devuelve el Arbol que representa la Colección.
	 * @param strRaiz @DefinicionParametro
	 * @param objIncluidos @DefinicionParametro
	 * @return @DefinicionReturn
	 * @throws SecurityException @DefinicionExcepcion
	 */
	public static DefaultMutableTreeNode crearEstructura(String strRaiz, ArrayList<ObjetoReflexion> objIncluidos) throws SecurityException {
            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz, strRaiz);
            DefaultMutableTreeNode nodoFolderAtributos = null;
            DefaultMutableTreeNode nodoFolderMetodos = null;
            DefaultMutableTreeNode nodoAtributo = null;
            DefaultMutableTreeNode nodoMetodo = null;

            nodoFolderAtributos = crearNodo("Atributos");
            nodoFolderMetodos = crearNodo("Métodos");

            try {
                for (ObjetoReflexion objItem : objIncluidos) {
                    if (objItem.getObj() instanceof Field) {
                        nodoAtributo = crearEstructura(objItem);
                        nodoFolderAtributos.add(nodoAtributo);
                    } else if (objItem.getObj() instanceof Method) {
                        nodoMetodo = crearEstructura(objItem);                                
                        nodoFolderMetodos.add(nodoMetodo);
                    }
                }
                nodoRaiz.add(nodoFolderAtributos);
                nodoRaiz.add(nodoFolderMetodos);
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
        
        /**
         * 
         * @param objField
         * @return
         * @throws SecurityException
         */
        public static DefaultMutableTreeNode crearEstructura(Field objField) throws SecurityException {
         try{
            DefaultMutableTreeNode nodoRaiz =
                    crearNodo(
                        objField.getName(),
                        objField
                    );            
            DefaultMutableTreeNode nodoTipoDato =
                    crearNodo(
                        objField.getType().getSimpleName(),
                        UtilRepresentacion.getTipoDatoReflexionToClass(objField.getType())
                    );            
            nodoRaiz.add(nodoTipoDato);
            return nodoRaiz;
	}catch(java.lang.NullPointerException ex){return null;}
         
        }

	/**
	 * Devuelve el Arbol que representa el Vector.
	 * @param objMetodo @DefinicionParametro
	 * @return @DefinicionReturn
	 * @throws SecurityException @DefinicionExcepcion
	 */
	public static DefaultMutableTreeNode crearEstructura(Method objMetodo) throws SecurityException {
          try{
                DefaultMutableTreeNode nodoRaiz = crearNodo(objMetodo.getName(), objMetodo);
                DefaultMutableTreeNode nodoFolderReturn = null;
                DefaultMutableTreeNode nodoFolderParams = null;
                DefaultMutableTreeNode nodoReturn = null;
                DefaultMutableTreeNode nodoParam = null;

                nodoFolderReturn = crearNodo("Valor de Retorno");
                nodoRaiz.add(nodoFolderReturn);

                nodoReturn =
                        crearNodo(
                            objMetodo.getReturnType().getSimpleName(),
                            UtilRepresentacion.getTipoDatoReflexionToClass(objMetodo.getReturnType())
                        );
                nodoFolderReturn.add(nodoReturn);

                nodoFolderParams = crearNodo("Parámetros");
                nodoRaiz.add(nodoFolderParams);

                List<Class<?>> list = Arrays.asList(objMetodo.getParameterTypes());

                try {
                    for (Class<?> objParam : list) {
                        nodoParam =
                                crearNodo(
                                    objParam.getSimpleName(),
                                    UtilRepresentacion.getTipoDatoReflexionToClass(objParam)
                                );
                        nodoFolderParams.add(nodoParam);
                    }
                    return nodoRaiz;
                } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
                } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
                }
                return null;
	}catch(java.lang.NullPointerException ex){return null;}        
     }

	/**
	 * Devuelve el Arbol que representa el Vector.
         * @param strRaiz @DefinicionParametro
         * @param objTipos @DefinicionParametro
         * @return @DefinicionReturn
         * @throws SecurityException @DefinicionExcepcion
	 */
	public static DefaultMutableTreeNode crearEstructuraTiposDeDatos(String strRaiz, ArrayList<ObjetoTipoDatoReflexion> objTipos) throws SecurityException {

            DefaultMutableTreeNode nodoRaiz = crearNodo(strRaiz);
            DefaultMutableTreeNode nodoTipoDato = null;
            try {
                for(ObjetoTipoDatoReflexion objTipoDato : objTipos) {                                        
                    if(!objTipoDato.isAbstractClass()){                    
                        nodoTipoDato = crearEstructura(objTipoDato);
                        if(nodoTipoDato != null){
                            nodoRaiz.add(nodoTipoDato);
                        }
                    }
                }
                return nodoRaiz;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
        
        /**
         * 
         * @param objTipoDato
         * @return
         */
        public static DefaultMutableTreeNode crearEstructura(ObjetoTipoDatoReflexion objTipoDato){            
            DefaultMutableTreeNode nodoClase = null;
            DefaultMutableTreeNode nodoGenericos = null;
            DefaultMutableTreeNode nodoGenerico = null;           
            
            nodoClase = crearNodoTipoDato(objTipoDato);
            
            try {                
                Class objClase = objTipoDato.getObjClass();
                if (objClase.isPrimitive()) {
                    nodoClase.add(crearNodo(objClase.getCanonicalName(), objClase));
                } else if (objClase.isArray()) {
                    nodoClase.add(crearNodo(objClase.getCanonicalName(), objClase));
                } else if (!objClase.isInterface()){
                    nodoClase.add(crearEstructura(objTipoDato.getObjClass()));
                }
                //Nuevo: visualizar Genericos
                if(!objTipoDato.getObjTiposGenericos().isEmpty()){
                    nodoGenericos = crearNodo("Tipos Genericos");
                    for(ObjetoTipoDatoReflexion objTipoDatoGenerico : objTipoDato.getObjTiposGenericos()){
                        Class objClaseTipoGenerico = objTipoDatoGenerico.getObjClass();
                        if (objClaseTipoGenerico.isPrimitive()) {
                            nodoGenerico = crearNodo(objClaseTipoGenerico.getCanonicalName(), objClaseTipoGenerico);
                        } else if (objClaseTipoGenerico.isArray()) {
                            nodoGenerico = crearNodo(objClaseTipoGenerico.getCanonicalName(), objClaseTipoGenerico);
                        } else {
                            nodoGenerico = crearEstructura(objClaseTipoGenerico);
                        }
                        nodoGenericos.add(nodoGenerico);
                    }
                    nodoClase.add(nodoGenericos);
                }                                    
                return nodoClase;
            } catch (java.lang.NullPointerException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                    Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
        }

	/**
	 * Devuelve el Arbol que representa el Vector.
         * @param objClase @DefinicionParametro
         * @return @DefinicionReturn
         * @throws SecurityException @DefinicionExcepcion
	 */
	public static DefaultMutableTreeNode crearEstructura(Class objClase) throws SecurityException {

            DefaultMutableTreeNode nodoFolder = null;
            DefaultMutableTreeNode nodoPaquete = null;
            DefaultMutableTreeNode nodoClase = null;
            DefaultMutableTreeNode nodoHoja = null;
            DefaultMutableTreeNode nodoInterfaz = null;
            DefaultMutableTreeNode nodoAnotacion = null;
            DefaultMutableTreeNode nodoConstructor = null;
            DefaultMutableTreeNode nodoAtributo = null;
            DefaultMutableTreeNode nodoMetodo = null;
            
            try {

                nodoClase = crearNodo(objClase.getCanonicalName(), objClase);

                Package objPackage = objClase.getPackage();
                nodoPaquete = crearNodo(objPackage.getName(), objPackage);                        
                nodoFolder = crearNodo("Paquete");
                nodoFolder.add(nodoPaquete);                        
                nodoClase.add(nodoFolder);

                nodoFolder = crearNodo("Atributos");
                nodoClase.add(nodoFolder);
                Field[] objAtributos = objClase.getFields();
                for (int j = 0; j < objAtributos.length; j++) {
                    Field objAtributo = objAtributos[j];
                    nodoAtributo = crearNodo(objAtributo.toGenericString(), objAtributo);
                    nodoFolder.add(nodoAtributo);
                }
                
                nodoFolder = crearNodo("Métodos");
                nodoClase.add(nodoFolder);
                Method[] objMetodos = objClase.getMethods();
                for (int j = 0; j < objMetodos.length; j++) {
                    Method objMetodo = objMetodos[j];
                    nodoMetodo = crearNodo(objMetodo.toGenericString(), objMetodo);
                    nodoFolder.add(nodoMetodo);
                }
                
                nodoFolder = crearNodo("Interfaces");
                nodoClase.add(nodoFolder);
                Class[] objInterfaces = objClase.getInterfaces();
                for (int j = 0; j < objInterfaces.length; j++) {
                    Class objInterfaz = objInterfaces[j];
                    nodoInterfaz = crearNodo(objInterfaz.getCanonicalName(), objInterfaz);
                    nodoFolder.add(nodoInterfaz);
                }
                
                nodoFolder = crearNodo("Anotaciones");
                nodoClase.add(nodoFolder);
                Annotation[] objAnotaciones = objClase.getAnnotations();
                for (int j = 0; j < objAnotaciones.length; j++) {
                    Annotation objAnotacion = objAnotaciones[j];
                    nodoAnotacion = crearNodo(objAnotacion.toString(), objAnotacion);
                    nodoFolder.add(nodoAnotacion);
                }
                
                nodoFolder = crearNodo("Constructores");
                nodoClase.add(nodoFolder);
                Constructor[] objConstructores = objClase.getConstructors();
                for (int j = 0; j < objConstructores.length; j++) {
                    Constructor objConstructor = objConstructores[j];
                    nodoConstructor = crearNodo(objConstructor.toGenericString(), objConstructor);
                    nodoFolder.add(nodoConstructor);
                }
                
                if (!objClase.getCanonicalName().equals("java.lang.Object")) {
                    nodoFolder = crearNodo("Super Clase");
                    nodoClase.add(nodoFolder);
                    Class objSuperClase = objClase.getSuperclass();
                    nodoHoja = crearNodo(objSuperClase.getCanonicalName(), objSuperClase);
                    nodoFolder.add(nodoHoja);
                }
                
                return nodoClase;
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ClassCastException ex) {
                Logger.getLogger(GeneradorArbol.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
	}
}
